C++ 禁止从 const char* 设置 char* 和 char[]

Question

这是代码。我不知道为什么它不承认它需要复制内存，而且我不能强迫它。

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

我看到有类似的线程，但没有。此外，C++ 不能那么容易地处理这似乎是一个缺点。

Answer 1

如何将文本分解为单词（简单的方法）

#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.
}

分解其工作原理（12 岁学习编程）

• 运算符>>在应用于流（和字符串）时读取单个（空白）空格分隔的单词。

  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...
  

• istream_iterator 是流的适配器，使它们看起来像容器。
  它使用运算符 >>

  从“T”类型的流中读取项目

  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
  

• 标准算法都适用于迭代器。
  std::copy 遍历源并将每个项目放在目标中：

  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
  

• back_inserter 是一个适配器，它使用 push_back 将项目添加到容器中。
  我们可以确保目标向量的大小正确。但是使用 back_inserter 来确保向量是动态调整大小更容易。

  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
  

• 将它们重新组合在一起：

  // 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

您想按空格将字符串拆分为标记。你应该使用合适的工具——例如Boost.Tokenizer。你的代码在几个方面是错误的：

1. 您不能这样定义数组，维度必须是编译时常量表达式。
2. 数组不是指针，不能分配给数组。
3. c_str 返回一个指针，只要字符串对象有效，该指针就有效。
4. 除非需要，否则不要使用char*。使该向量保持std::string。
5. c_str 返回一个 char*，它没有 length 成员函数或任何与此相关的成员函数。

这表明你缺乏一些 C++ 基础知识。您或许应该阅读a good book on C++。所以，不，这不是 C++ 的缺点。

真的，只需使用 Boost.Tokenizer。它在文档中有一个按空格分割的示例。

Answer 3

string 的substr 方法返回一个新的临时字符串，而c_str 方法返回一个指向该临时字符串内存的指针。 简而言之，将指针保存到临时缓冲区会导致未定义的行为。 如果您想保留子字符串，请改用string 类。 (i.e. vector<string>)

Answer 4

天哪

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++]);

这是，假设您想要指向每个字符的指针（我不知道您为什么会这样，但这是您编写的代码）。

顺便说一句，你想做什么？

Answer 5

通常，您只需使用vector<string>。作为 C++ 中的一般规则，看到原始指针是一个巨大的警告信号——要么使用智能指针并动态分配内存，要么使用值类型——例如std::string。

Answer 6

你想要数组中单词的副本，还是只是指向原始单词的指针？

如果你想要副本，那么你需要一个字符串向量。

此代码将创建单词的副本：

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

此代码将为您提供指向原始单词的指针：

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