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.