Q:

How to work with null pointers in a std::vector

Say I have a vector of null terminates strings some of which may be null pointers. I don't know even if this is legal. It is a learning exercise. Example code
std::vector<char*> c_strings1;
char* p1 = "Stack Over Flow";
c_strings1.push_back(p1);
p1 = NULL; // I am puzzled you can do this and what exactly is stored at this memory location
c_strings1.push_back(p1);
p1 = "Answer";
c_strings1.push_back(p1);
for(std::vector<char*>::size_type i = 0; i < c_strings1.size(); ++i)
{
  if( c_strings1[i] != 0 )
  {
    cout << c_strings1[i] << endl;
  }
}

Note that the size of vector is 3 even though I have a NULL at location c_strings1[1]
Question. How can you re-write this code using std::vector<char>
 What exactly is stored in the vector when you push a null value? 

EDIT
The first part of my question has been thoroughly answered but not the second. Not to my statisfaction at least. I do want to see usage of vector<char>; not some nested variant or std::vector<std::string> Those are familiar. So here is what I tried ( hint: it does not work) 
std::vector<char> c_strings2;
string s = "Stack Over Flow";
c_strings2.insert(c_strings2.end(), s.begin(), s.end() );
//  char* p = NULL; 
s = ""; // this is not really NULL, But would want a NULL here
c_strings2.insert(c_strings2.end(), s.begin(), s.end() );
s = "Answer";
c_strings2.insert(c_strings2.end(), s.begin(), s.end() );

const char *cs = &c_strings2[0];
while (cs <= &c_strings2[2]) 
{
  std::cout << cs << "\n";
  cs += std::strlen(cs) + 1;
}

A:

You don't have a vector of strings -- you have a vector of pointer-to-char.  NULL is a perfectly valid pointer-to-char which happens to not point to anything, so it is stored in the vector.
Note that the pointers you are actually storing are pointers to char literals.  The strings are not copied.  
It doesn't make a lot of sense to mix the C++ style vector with the C-style char pointers.  Its not illegal to do so, but mixing paradigms like this often results in confused & busted code.
Instead of using a vector<char*> or a vector<char>, why not use a vector<string> ?
EDIT
Based on your edit, it seems like what your'e trying to do is flatten several strings in to a single vector<char>, with a NULL-terminator between each of the flattened strings.
Here's a simple way to accomplish this:
#include <algorithm>
#include <vector>
#include <string>
#include <iterator>
using namespace std;

int main()
{
    // create a vector of strings...
    typedef vector<string> Strings;
    Strings c_strings;

    c_strings.push_back("Stack Over Flow");
    c_strings.push_back("");
    c_strings.push_back("Answer");

    /* Flatten the strings in to a vector of char, with 
        a NULL terminator between each string

        So the vector will end up looking like this:

        S t a c k _ O v e r _ F l o w \0 \0 A n s w e r \0

    ***********************************************************/

    vector<char> chars;
    for( Strings::const_iterator s = c_strings.begin(); s != c_strings.end(); ++s )
    {
        // append this string to the vector<char>
        copy( s->begin(), s->end(), back_inserter(chars) );
        // append a null-terminator
        chars.push_back('\0');
    }
}

A:

I have a funny feeling that what you would really want is to have the vector contain something like "Stack Over Flow Answer" (possibly without space before "Answer").
In this case, you can use a std::vector<char>, you just have to push the whole arrays, not just pointers to them.
This cannot be accomplished with push_back, however vector have an insert method that accept ranges.
/// Maintain the invariant that the vector shall be null terminated
/// p shall be either null or point to a null terminated string
void push_back(std::vector<char>& v, char const* p) {
  if (p) {
    v.insert(v.end(), p, p + strlen(p));
  }

  v.push_back('\0');
} // push_back

int main() {
  std::vector<char> v;

  push_back(v, "Stack Over Flow");
  push_back(v, 0);
  push_back(v, "Answer");

  for (size_t i = 0, max = v.size(); i < max; i += strlen(&v[i]) + 1) {
    std::cout << &v[i] << "\n";
  }
}

This uses a single contiguous buffer to store multiple null-terminated strings. Passing a null string to push_back results in an empty string being displayed.

