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 le开发者_运维百科ast. 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;
}

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');
    }
}

So,

char *p1 = "Stack Over Flow";
char *p2 = NULL;
char *p3 = "Answer";

If you notice, the type of all three of those is exactly the same. They are all char *. Because of this, we would expect them all to have the same size in memory as well.

You may think that it doesn't make sense for them to have the same size in memory, because p3 is shorter than p1. What actually happens, is that the compiler, at compile-time, will find all of the strings in the program. In this case, it would find "Stack Over Flow" and "Answer". It will throw those to some constant place in memory, that it knows about. Then, when you attempt to say that p3 = "Answer", the compiler actually transforms that to something like p3 = 0x123456A0.

Therefore, with either version of the push_back call, you are only pushing into the vector a pointer, not the actual string itself.

The vector itself, doesn't know, or care that a NULL char * is an empty string. So in it's counting, it sees that you have pushed three pointers into it, so it reports a size of 3.

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.

What exactly is stored in the vector when you push a null value?

A NULL. You're storing pointers, and NULL is a possible value for a pointer. Why is this unexpected in any way?

Also, use std::string as the value type (i.e. std::vector<std::string>), char* shouldn't be used unless it's needed for C interop. To replicate your code using std::vector<char>, you'd need std::vector<std::vector<char>>.

You have to be careful when storing pointers in STL containers - copying the containers results in shallow copy and things like that.

With regard to your specific question, the vector will store a pointer of type char* regardless of whether or not that pointer points to something. It's entirely possible you would want to store a null-pointer of type char* within that vector for some reason - for example, what if you decide to delete that character string at a later point from the vector? Vectors only support amortized constant time for push_back and pop_back, so there's a good chance if you were deleting a string inside that vector (but not at the end) that you would prefer to just set it null quickly and save some time.

Moving on - I would suggest making a std::vector > if you want a dynamic array of strings which looks like what you're going for.

A std::vector as you mentioned would be useless compared to your original code because your original code stores a dynamic array of strings and a std::vector would only hold one dynamically changable string (as a string is an array of characters essentially).

NULL is just 0. A pointer with value 0 has a meaning. But a char with value 0 has a different meaning. It is used as a delimiter to show the end of a string. Therefore, if you use std::vector<char> and push_back 0, the vector will contain a character with value 0. vector<char> is a vector of characters, while std::vector<char*> is a vector of C-style strings -- very different things.

Update. As the OP wants, I am giving an idea of how to store (in a vector) null terminated strings some of which are nulls.

Option 1: Suppose we have vector<char> c_strings;. Then, we define a function to store a string pi. A lot of complexity is introduced since we need to distinguish between an empty string and a null char*. We select a delimiting character that does not occur in our usage. Suppose this is the '~' character.

char delimiter = '~';
// push each character in pi into c_strings
void push_into_vec(vector<char>& c_strings, char* pi) {
  if(pi != 0) {
    for(char* p=pi; *p!='\0'; p++) 
      c_strings.push_back(*p);
    // also add a NUL character to denote end-of-string
    c_strings.push_back('\0');
  }
  c_strings.push_back(deimiter);
  // Note that a NULL pointer would be stored as a single '~' character
  // while an empty string would be stored as '\0~'.
}
 
// now a method to retrieve each of the stored strings. 
vector<char*> get_stored_strings(const vector<char>& c_strings) {
  vector<char*> r;
  char* end = &c_strings[0] + c_strings.size();
  char* current = 0;
  bool nullstring = true; 
  for(char* c = current = &c_strings[0]; c != end+1; c++) {
    if(*c == '\0') {
      int size = c - current - 1;
      char* nc = new char[size+1];
      strncpy(nc, current, size);  
      r.push_back(nc);     
      nullstring = false; 
    }
    if(*c == delimiter) {
      if(nullstring) r.push_back(0);     
      nullstring = true; // reset nullstring for the next string
      current = c+1; // set the next string
    }
  }
  return r;
}

You still need to call delete[] on the memory allocated by new[] above. All this complexity is taken care of by using the string class. I very rarely use char* in C++.

Option 2: You could use vector<boost::optional<char> > . Then the '~' can be replaced by an empty boost::optional, but other other parts are the same as option 1. But the memory usage in this case would be higher.