MFC/ATL有一个非常好的标记器。从MSDN:

CAtlString str( "%First Second#Third" );
CAtlString resToken;
int curPos= 0;

resToken= str.Tokenize("% #",curPos);
while (resToken != "")
{
   printf("Resulting token: %s\n", resToken);
   resToken= str.Tokenize("% #",curPos);
};

Output

Resulting Token: First
Resulting Token: Second
Resulting Token: Third

我知道你想要一个c++的解决方案，但你可能会认为这是有帮助的:

Qt

#include <QString>

...

QString str = "The quick brown fox"; 
QStringList results = str.split(" "); 

在这个例子中，与Boost相比的优势在于，它直接一对一地映射到你的文章代码。

详见Qt文档

我知道这个问题已经有了答案，但我想有所贡献。也许我的解决方案有点简单，但这就是我想到的:

vector<string> get_words(string const& text, string const& separator)
{
    vector<string> result;
    string tmp = text;

    size_t first_pos = 0;
    size_t second_pos = tmp.find(separator);

    while (second_pos != string::npos)
    {
        if (first_pos != second_pos)
        {
            string word = tmp.substr(first_pos, second_pos - first_pos);
            result.push_back(word);
        }
        tmp = tmp.substr(second_pos + separator.length());
        second_pos = tmp.find(separator);
    }

    result.push_back(tmp);

    return result;
}

如果在我的代码中有更好的方法，或者有什么错误，请评论。

更新:添加通用分隔符

如果你愿意使用C语言，你可以使用strtok函数。在使用它时，您应该注意多线程问题。

c++标准库算法普遍基于迭代器，而不是具体的容器。不幸的是，这使得在c++标准库中很难提供类似java的split函数，尽管没有人认为这很方便。但是它的返回类型是什么呢?std::向量< std:: basic_string <…> >吗?也许吧，但这样我们就被迫执行(可能是冗余的和昂贵的)分配。

相反，c++提供了大量基于任意复杂的分隔符分割字符串的方法，但它们都没有像其他语言中那样封装得很好。各种各样的方法填满了整个博客文章。

在最简单的情况下，你可以使用std::string::find进行迭代，直到你击中std::string::npos，然后使用std::string::substr提取内容。

一个更流畅的(和惯用的，但基本的)版本在空格上拆分将使用std::istringstream:

auto iss = std::istringstream{"The quick brown fox"};
auto str = std::string{};

while (iss >> str) {
    process(str);
}

使用std::istream_iterators，还可以使用vector的迭代器范围构造函数将string流的内容复制到vector中。

多个库(如Boost.Tokenizer)提供特定的标记器。

更高级的分裂需要正则表达式。c++特别为此提供了std::regex_token_iterator:

auto const str = "The quick brown fox"s;
auto const re = std::regex{R"(\s+)"};
auto const vec = std::vector<std::string>(
    std::sregex_token_iterator{begin(str), end(str), re, -1},
    std::sregex_token_iterator{}
);

对于简单的事情，我只使用以下方法:

unsigned TokenizeString(const std::string& i_source,
                        const std::string& i_seperators,
                        bool i_discard_empty_tokens,
                        std::vector<std::string>& o_tokens)
{
    unsigned prev_pos = 0;
    unsigned pos = 0;
    unsigned number_of_tokens = 0;
    o_tokens.clear();
    pos = i_source.find_first_of(i_seperators, pos);
    while (pos != std::string::npos)
    {
        std::string token = i_source.substr(prev_pos, pos - prev_pos);
        if (!i_discard_empty_tokens || token != "")
        {
            o_tokens.push_back(i_source.substr(prev_pos, pos - prev_pos));
            number_of_tokens++;
        }

        pos++;
        prev_pos = pos;
        pos = i_source.find_first_of(i_seperators, pos);
    }

    if (prev_pos < i_source.length())
    {
        o_tokens.push_back(i_source.substr(prev_pos));
        number_of_tokens++;
    }

    return number_of_tokens;
}

懦弱的免责声明:我编写实时数据处理软件，其中数据通过二进制文件、套接字或一些API调用(I/O卡、摄像头)传入。除了在启动时读取外部配置文件以外，我从未将这个函数用于更复杂或时间要求更严格的事情。