C++ forbidding setting char* and char[] from const char*

Question

Here's the code. I have no idea why it doesn't recognize that it needs to copy the memory, and I can't force it to.

 string message="The quick brown fox jumped over the lazy dog.";

  vector<char*> words;

  while(message.length()>0){
    char wtf[message.substr(0,message.find(" ")).c_str().length()]=message.substr(0,message.find(" ")).c_str();
    words.push_back(wtf);
    message=message.substr(message.find(" ")+1);
  }

I see that there are similar threads, but none on this. Also, it seems like a shortcomming that C++ can't deal with this that easily.

Answer 1

How to break text into words (the easy way)

#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <iterator>

int main()
{
    std::string message="The quick brown fox jumped over the lazy dog.";

    std::vector<std::string>    words;

    std::stringstream   stream(message);                  // 1: Create a stream
    std::copy(std::istream_iterator<std::string>(stream), // 2: Copy words from the stream
              std::istream_iterator<std::string>(),
              std::back_inserter(words));                 //    into the back of the vector.
}

A break down on how it works (for 12 year old's learning to program)

• The operator >> when applied to a stream (and a string) reads a single (white) space separated word.

  std::string message="The quick brown fox jumped over the lazy dog.";
  std::stringstream   stream(message);
  
  std::string  word;
  stream >> word; // Reads "The"
  stream >> word; // Reads "quick"
  stream >> word; // Reads "brown" etc...
  

• The istream_iterator is an adapter for streams that make them look like containers.
  It reads items from the stream of type 'T' using the operator >>

  std::stringstream   stream("The quick brown fox jumped over the lazy dog.");
  std::istream_iterator<std::string> i(stream);
  
  std::string  word;
  
  word = *i;      // de-reference the iterator to get the object.   Reads "The"
  ++i;
  word = *i; ++i; // Reads "quick"
  word = *i; ++i; // Reads "brown" etc
  
  // Works for any type that uses >> to read from the stream 
  std::stringstream   intstream("99 40 32 64 20 10 9 8 102");
  std::istream_iterator<int> i(stream);  // Notice the type is int here
  
  int   number;
  
  number = *i;      // de-reference the iterator to get the object.   Reads "99"
  ++i;
  number = *i; ++i; // Reads "44"
  number = *i; ++i; // Reads "32" etc
  

• The standard algorithms all work on iterators.
  std::copy iterates over the source and places each item in the destination:

  int    src[] = { 1, 2, 3, 4, 5, 6 };
  int    dst[] = { 0, 0, 0, 0, 0, 0 };
  
  std::copy(src, src+6, dst); // copies src into dst
                              // It assumes there is enough space in dst
  

• The back_inserter is an adapter that uses push_back to add items to the container.
  We could have made sure that the destination vector was the correct size. But it is easier to use the back_inserter to make sure the vector is dynamically sized.

  int    src[] = { 1, 2, 3, 4, 5, 6 };
  std::vector<int> dst; // Currently has zero size
  
  std::copy(src, src+6, std::back_inserter(dst)); // copies src into dst
                                                  // back_inserter expands dst to fit
                                                  // by using push_back
  

• Putting it all back together:

  // Create a stream from the string
  std::stringstream   stream(message);
  
  // Use std::copy to copy from the string.
  //     The stream is iterated over a word at a time.
  //     because the istream iterator is using std::string type.
  //
  //     The istream_iterator with no parameters is equivelent to end.
  //
  //     The destination appends the word to the vector words.
  std::copy(std::istream_iterator<std::string>(stream), // 2: Copy words from the stream
            std::istream_iterator<std::string>(),
            std::back_inserter(words));                 //    into the back of the vector.
  

Answer 2

You want to split a string into tokens by space. You should use a proper tool — Boost.Tokenizer for example. Your code is wrong in several ways:

1. You cannot define an array like that, the dimension must be a compile-time constant expression.
2. Arrays are not pointers, and you cannot assign to an array.
3. c_str returns a pointer that's valid as long as the string object is valid.
4. Don't use char* unless you need to. Make that vector hold std::string.
5. c_str returns a char* which doesn't have length member function, or any member function for that matter.

This indicates that you lack some fundamental knowlegde in C++. You should perhaps read a good book on C++. So, no, it's not a shortcoming of C++.

Really, just use Boost.Tokenizer. It has an example of splitting by space in the docs.

Answer 3

string's substr method returns a new temporary string, while the c_str method returns a pointer right into the memory of that temporary string. Simply put, holding a pointer into the temporary buffer results in undefined behavior. If you wan to keep sub-strings, use the string class instead. (i.e. vector<string>)

Answer 4

Do you want copies of the words in the array, or just pointers into the original?

If you want copies, then you'll need a vector of strings.

This code will create copies of the words:

vector<string> words;
string::iterator it1 = message.begin();
string::iterator it2 = find(message.begin(), message.end(), ' ');
while (it2 != message.end())
{
    words.push_back(string(it1, it2));
    it1 = ++it2;
    it2 = find(it2, message.end(), ' ');
}
words.push_back(string(it1, it2));

This code will give you pointers into the original words:

vector<char*> words;
string::iterator it1 = message.begin();
string::iterator it2 = find(message.begin(), message.end(), ' ');
while (it2 != message.end())
{
    words.push_back(&*it1);
    it1 = ++it2;
    it2 = find(it2, message.end(), ' ');
}
words.push_back(&*it1);

Answer 5

OMG

char *message="The quick brown fox jumped over the lazy dog.";

vector<char*> words;

int p=0;
while(message[p])
{
 words.push_back(&message[p++]);
}

//if you Must use a string, change to 
words.push_back(&message.c_str()[p++]);

This is, supposing you want Pointers to each character (I don't know why you would like that but that is what you have coded).

What are you trying to do BTW?

Answer 6

Typically, you would just use vector<string>. As a general rule in C++, it's a huge warning sign to see raw pointers- either use smart pointers and allocate the memory dynamically, or use value types - such as std::string.