如何在 C++ 中标记字符串？

Question

Java 有一个方便的 split 方法：

String str = "The quick brown fox";
String[] results = str.split(" ");

在 C++ 中是否有一种简单的方法可以做到这一点？

Answer 1

您可以利用 boost::make_find_iterator。 与此类似的东西：

template<typename CH>
inline vector< basic_string<CH> > tokenize(
    const basic_string<CH> &Input,
    const basic_string<CH> &Delimiter,
    bool remove_empty_token
    ) {

    typedef typename basic_string<CH>::const_iterator string_iterator_t;
    typedef boost::find_iterator< string_iterator_t > string_find_iterator_t;

    vector< basic_string<CH> > Result;
    string_iterator_t it = Input.begin();
    string_iterator_t it_end = Input.end();
    for(string_find_iterator_t i = boost::make_find_iterator(Input, boost::first_finder(Delimiter, boost::is_equal()));
        i != string_find_iterator_t();
        ++i) {
        if(remove_empty_token){
            if(it != i->begin())
                Result.push_back(basic_string<CH>(it,i->begin()));
        }
        else
            Result.push_back(basic_string<CH>(it,i->begin()));
        it = i->end();
    }
    if(it != it_end)
        Result.push_back(basic_string<CH>(it,it_end));

    return Result;
}

Answer 2

我刚刚阅读了所有答案，但无法找到下一个先决条件的解决方案：

1. 没有动态内存分配，
2. 没有使用 boost，
3. 没有使用正则表达式
4. c++17 标准，

所以这是我的解决方案

#include <iomanip>
#include <iostream>
#include <iterator>
#include <string_view>
#include <utility>

struct split_by_spaces
{
    std::string_view      text;
    static constexpr char delim = ' ';

    struct iterator
    {
        const std::string_view& text;
        std::size_t             cur_pos;
        std::size_t             end_pos;

        std::string_view operator*() const
        {
            return { &text[cur_pos], end_pos - cur_pos };
        }
        bool operator==(const iterator& other) const
        {
            return cur_pos == other.cur_pos && end_pos == other.end_pos;
        }
        bool operator!=(const iterator& other) const
        {
            return !(*this == other);
        }
        iterator& operator++()
        {
            cur_pos = text.find_first_not_of(delim, end_pos);

            if (cur_pos == std::string_view::npos)
            {
                cur_pos = text.size();
                end_pos = cur_pos;
                return *this;
            }

            end_pos = text.find(delim, cur_pos);

            if (end_pos == std::string_view::npos)
            {
                end_pos = text.size();
            }

            return *this;
        }
    };

    [[nodiscard]] iterator begin() const
    {
        auto start = text.find_first_not_of(delim);
        if (start == std::string_view::npos)
        {
            return iterator{ text, text.size(), text.size() };
        }
        auto end_word = text.find(delim, start);
        if (end_word == std::string_view::npos)
        {
            end_word = text.size();
        }
        return iterator{ text, start, end_word };
    }
    [[nodiscard]] iterator end() const
    {
        return iterator{ text, text.size(), text.size() };
    }
};

int main(int argc, char** argv)
{
    using namespace std::literals;
    auto str = " there should be no memory allocation during parsing"
               "  into words this line and you   should'n create any"
               "  contaner                  for intermediate words  "sv;

    auto comma = "";
    for (std::string_view word : split_by_spaces{ str })
    {
        std::cout << std::exchange(comma, ",") << std::quoted(word);
    }

    auto only_spaces = "                   "sv;
    for (std::string_view word : split_by_spaces{ only_spaces })
    {
        std::cout << "you will not see this line in output" << std::endl;
    }
}

Answer 3

我编写了 https://stackoverflow.com/a/50247503/3976739 供我自己使用。 我希望它会有所帮助。

void StrTokenizer(string& source, const char* delimiter, vector<string>& Tokens)
{   
   size_t new_index = 0;
   size_t old_index = 0;

   while (new_index != std::string::npos)   
   {
      new_index = source.find(delimiter, old_index);
      Tokens.emplace_back(source.substr(old_index, new_index-old_index));

      if (new_index != std::string::npos)
          old_index = ++new_index;
   }
}

Answer 4

这是我的字符串标记器 Swiss® Army Knife，用于按空格分割字符串、解释单引号和双引号包裹的字符串以及从结果中剥离这些字符。 我使用 RegexBuddy 4.x 生成大部分代码片段，但我添加了用于剥离引号和其他一些内容的自定义处理。

#include <string>
#include <locale>
#include <regex>

std::vector<std::wstring> tokenize_string(std::wstring string_to_tokenize) {
    std::vector<std::wstring> tokens;

    std::wregex re(LR"(("[^"]*"|'[^']*'|[^"' ]+))", std::regex_constants::collate);

    std::wsregex_iterator next( string_to_tokenize.begin(),
                                string_to_tokenize.end(),
                                re,
                                std::regex_constants::match_not_null );

    std::wsregex_iterator end;
    const wchar_t single_quote = L'\'';
    const wchar_t double_quote = L'\"';
    while ( next != end ) {
        std::wsmatch match = *next;
        const std::wstring token = match.str( 0 );
        next++;

        if (token.length() > 2 && (token.front() == double_quote || token.front() == single_quote))
            tokens.emplace_back( std::wstring(token.begin()+1, token.begin()+token.length()-1) );
        else
            tokens.emplace_back(token);
    }
    return tokens;
}

Answer 5

对我来说，这似乎很奇怪，对于我们所有注重速度的书呆子来说，没有人提出一个使用编译时生成的查找表作为分隔符的版本（下面的示例实现）。 使用查找表和迭代器应该在效率上击败 std::regex ，如果您不需要击败正则表达式，只需使用它，它是 C++11 的标准并且超级灵活。

有些人已经建议使用正则表达式，但对于菜鸟来说，这里是一个打包的示例，它应该完全符合OP的期望：

std::vector<std::string> split(std::string::const_iterator it, std::string::const_iterator end, std::regex e = std::regex{"\\w+"}){
    std::smatch m{};
    std::vector<std::string> ret{};
    while (std::regex_search (it,end,m,e)) {
        ret.emplace_back(m.str());              
        std::advance(it, m.position() + m.length()); //next start position = match position + match length
    }
    return ret;
}
std::vector<std::string> split(const std::string &s, std::regex e = std::regex{"\\w+"}){  //comfort version calls flexible version
    return split(s.cbegin(), s.cend(), std::move(e));
}
int main ()
{
    std::string str {"Some people, excluding those present, have been compile time constants - since puberty."};
    auto v = split(str);
    for(const auto&s:v){
        std::cout << s << std::endl;
    }
    std::cout << "crazy version:" << std::endl;
    v = split(str, std::regex{"[^e]+"});  //using e as delim shows flexibility
    for(const auto&s:v){
        std::cout << s << std::endl;
    }
    return 0;
}

如果我们需要更快并接受所有字符必须是8位的约束，我们可以在编译时创建一个查找表使用元编程：

template<bool...> struct BoolSequence{};        //just here to hold bools
template<char...> struct CharSequence{};        //just here to hold chars
template<typename T, char C> struct Contains;   //generic
template<char First, char... Cs, char Match>    //not first specialization
struct Contains<CharSequence<First, Cs...>,Match> :
    Contains<CharSequence<Cs...>, Match>{};     //strip first and increase index
template<char First, char... Cs>                //is first specialization
struct Contains<CharSequence<First, Cs...>,First>: std::true_type {}; 
template<char Match>                            //not found specialization
struct Contains<CharSequence<>,Match>: std::false_type{};

template<int I, typename T, typename U> 
struct MakeSequence;                            //generic
template<int I, bool... Bs, typename U> 
struct MakeSequence<I,BoolSequence<Bs...>, U>:  //not last
    MakeSequence<I-1, BoolSequence<Contains<U,I-1>::value,Bs...>, U>{};
template<bool... Bs, typename U> 
struct MakeSequence<0,BoolSequence<Bs...>,U>{   //last  
    using Type = BoolSequence<Bs...>;
};
template<typename T> struct BoolASCIITable;
template<bool... Bs> struct BoolASCIITable<BoolSequence<Bs...>>{
    /* could be made constexpr but not yet supported by MSVC */
    static bool isDelim(const char c){
        static const bool table[256] = {Bs...};
        return table[static_cast<int>(c)];
    }   
};
using Delims = CharSequence<'.',',',' ',':','\n'>;  //list your custom delimiters here
using Table = BoolASCIITable<typename MakeSequence<256,BoolSequence<>,Delims>::Type>;

有了它，制作 getNextToken 函数就很容易：

template<typename T_It>
std::pair<T_It,T_It> getNextToken(T_It begin,T_It end){
    begin = std::find_if(begin,end,std::not1(Table{})); //find first non delim or end
    auto second = std::find_if(begin,end,Table{});      //find first delim or end
    return std::make_pair(begin,second);
}

使用它也很容易：

int main() {
    std::string s{"Some people, excluding those present, have been compile time constants - since puberty."};
    auto it = std::begin(s);
    auto end = std::end(s);
    while(it != std::end(s)){
        auto token = getNextToken(it,end);
        std::cout << std::string(token.first,token.second) << std::endl;
        it = token.second;
    }
    return 0;
}

这是一个实例：http://ideone.com/GKtkLQ

Answer 6

这是一种允许您控制是否包含空标记（如 strsep）或排除空标记（如 strtok）的方法。

#include <string.h> // for strchr and strlen

/*
 * want_empty_tokens==true  : include empty tokens, like strsep()
 * want_empty_tokens==false : exclude empty tokens, like strtok()
 */
std::vector<std::string> tokenize(const char* src,
                                  char delim,
                                  bool want_empty_tokens)
{
  std::vector<std::string> tokens;

  if (src and *src != '\0') // defensive
    while( true )  {
      const char* d = strchr(src, delim);
      size_t len = (d)? d-src : strlen(src);

      if (len or want_empty_tokens)
        tokens.push_back( std::string(src, len) ); // capture token

      if (d) src += len+1; else break;
    }

  return tokens;
}

Answer 7

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

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

如果我的代码中有更好的方法或者有问题，请发表评论。

更新：添加了通用分隔符

Answer 8

这里有许多过于复杂的建议。 尝试这个简单的 std::string 解决方案：

using namespace std;

string someText = ...

string::size_type tokenOff = 0, sepOff = tokenOff;
while (sepOff != string::npos)
{
    sepOff = someText.find(' ', sepOff);
    string::size_type tokenLen = (sepOff == string::npos) ? sepOff : sepOff++ - tokenOff;
    string token = someText.substr(tokenOff, tokenLen);
    if (!token.empty())
        /* do something with token */;
    tokenOff = sepOff;
}

Answer 9

我认为这就是字符串流上的 >> 运算符的用途：

string word; sin >> word;

Answer 10

您可以简单地使用 正则表达式库 并使用正则表达式解决该问题。

使用表达式 (\w+) 和 \1 中的变量（或 $1，具体取决于正则表达式的库实现）。

Answer 11

如果您愿意使用 C，则可以使用 strtok功能。 使用时要注意多线程问题。

Answer 12

对于简单的东西，我只使用以下内容：

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 卡、相机）传入。 我从来没有使用此功能来处理比在启动时读取外部配置文件更复杂或时间紧迫的事情。

Answer 13

检查这个例子。 它可能会帮助你..

#include <iostream>
#include <sstream>

using namespace std;

int main ()
{
    string tmps;
    istringstream is ("the dellimiter is the space");
    while (is.good ()) {
        is >> tmps;
        cout << tmps << "\n";
    }
    return 0;
}

Answer 14

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

Answer 15

我针对类似问题发布了此答案。
不要重新发明轮子。 我使用过许多库，我遇到的最快、最灵活的是： C++ String Toolkit图书馆。

这是我在 stackoverflow 上其他地方发布的如何使用它的示例。

#include <iostream>
#include <vector>
#include <string>
#include <strtk.hpp>

const char *whitespace  = " \t\r\n\f";
const char *whitespace_and_punctuation  = " \t\r\n\f;,=";

int main()
{
    {   // normal parsing of a string into a vector of strings
       std::string s("Somewhere down the road");
       std::vector<std::string> result;
       if( strtk::parse( s, whitespace, result ) )
       {
           for(size_t i = 0; i < result.size(); ++i )
            std::cout << result[i] << std::endl;
       }
    }

    {  // parsing a string into a vector of floats with other separators
       // besides spaces

       std::string s("3.0, 3.14; 4.0");
       std::vector<float> values;
       if( strtk::parse( s, whitespace_and_punctuation, values ) )
       {
           for(size_t i = 0; i < values.size(); ++i )
            std::cout << values[i] << std::endl;
       }
    }

    {  // parsing a string into specific variables

       std::string s("angle = 45; radius = 9.9");
       std::string w1, w2;
       float v1, v2;
       if( strtk::parse( s, whitespace_and_punctuation, w1, v1, w2, v2) )
       {
           std::cout << "word " << w1 << ", value " << v1 << std::endl;
           std::cout << "word " << w2 << ", value " << v2 << std::endl;
       }
    }

    return 0;
}

Answer 16

Adam Pierce 的答案提供了一个手工分词器，它接受 const char*。 使用迭代器会出现一些问题，因为递增字符串的结束迭代器未定义 。 也就是说，给定 string str{ "The Quick Brown Fox" } 我们当然可以实现这一点：

auto start = find(cbegin(str), cend(str), ' ');
vector<string> tokens{ string(cbegin(str), start) };

while (start != cend(str)) {
    const auto finish = find(++start, cend(str), ' ');

    tokens.push_back(string(start, finish));
    start = finish;
}

实例

---

如果您希望通过使用标准功能来抽象复杂性，正如On Freund建议的 strtok 是一个简单的选项：

vector<string> tokens;

for (auto i = strtok(data(str), " "); i != nullptr; i = strtok(nullptr, " ")) tokens.push_back(i);

如果您无权访问 C++17，则需要替换 data(str)，如下例所示：http://ideone.com/8kAGoa

虽然示例中没有演示，但 strtok 不需要为每个标记使用相同的分隔符。 尽管有这个优点，但也有几个缺点：

1. strtok 不能同时用于多个 string：必须传递 nullptr要继续标记当前的 string 或必须传递要标记的新 char* （但是有一些非标准实现确实支持此操作，例如：strtok_s）
2. 出于同样的原因strtok< /code> 不能同时在多个线程上使用（但这可能是实现定义的，例如： Visual Studio 的实现是线程安全的）
3. 调用 strtok 会修改它正在操作的 string，因此不能在 const string 上使用s、const char*s 或文字字符串，用 strtok 对其中任何一个进行标记，或者对一个 string 进行操作需要保留内容，需要复制str，然后可以对

---

c++20 为我们提供了 split_view 以非破坏性的方式标记字符串：< a href="https://topanswers.xyz/cplusplus?q=749#a874" rel="noreferrer">https://topanswers.xyz/cplusplus?q=749#a874

---

前面的方法无法生成就地标记化的向量，这意味着如果不将它们抽象为辅助函数，它们就无法初始化const向量<字符串>； 令牌。 可以使用 istream_iterator。 例如给定： const string str{ "The Quick \tbrown \nfox" } 我们可以这样做：

istringstream is{ str };
const vector<string> tokens{ istream_iterator<string>(is), istream_iterator<string>() };

实时示例

此选项所需的 istringstream 构建成本比前两个选项高得多，但是此成本通常隐藏在 <代码>字符串分配。

---

如果上述选项都不足以满足您的标记化需求，最灵活的选项是使用 当然，这种灵活性会带来更大的费用，但这很可能隐藏在字符串分配成本中。 举例来说，我们想要基于非转义逗号进行标记，同时也吃掉空格，给定以下输入：const string str{ "The ,qu\\,ick ,\tbrown, Fox" } 我们可以这样做：

const regex re{ "\\s*((?:[^\\\\,]|\\\\.)*?)\\s*(?:,|$)" };
const vector<string> tokens{ sregex_token_iterator(cbegin(str), cend(str), re, 1), sregex_token_iterator() };

实例

Answer 17

pystring 是一个小型库，它实现了一堆 Python 的字符串函数，包括 split 方法：

#include <string>
#include <vector>
#include "pystring.h"

std::vector<std::string> chunks;
pystring::split("this string", chunks);

// also can specify a separator
pystring::split("this-string", chunks, "-");

Answer 18

如果您使用的是 C++ 范围 - 完整的 ranges-v3 库，而不是接受的有限功能进入 C++20 - 你可以这样做：

auto results = str | ranges::views::tokenize(" ",1);

...这是惰性评估的。 您也可以将向量设置为此范围：

auto results = str | ranges::views::tokenize(" ",1) | ranges::to<std::vector>();

如果 str 有 n 个字符组成 m 个单词，则这将占用 O(m) 空间和 O(n) 时间。

另请参阅库自己的标记化示例，此处 。

Answer 19

我知道您要求使用 C++ 解决方案，但您可能会认为这很有帮助：

Qt

#include <QString>

...

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

在此示例中，相对于 Boost 的优势在于它是到您帖子代码的直接一对一映射。

如需了解更多信息，请访问 Qt 文档

Answer 20

这是一个示例标记生成器类，可以执行您想要的

//Header file
class Tokenizer 
{
    public:
        static const std::string DELIMITERS;
        Tokenizer(const std::string& str);
        Tokenizer(const std::string& str, const std::string& delimiters);
        bool NextToken();
        bool NextToken(const std::string& delimiters);
        const std::string GetToken() const;
        void Reset();
    protected:
        size_t m_offset;
        const std::string m_string;
        std::string m_token;
        std::string m_delimiters;
};

//CPP file
const std::string Tokenizer::DELIMITERS(" \t\n\r");

Tokenizer::Tokenizer(const std::string& s) :
    m_string(s), 
    m_offset(0), 
    m_delimiters(DELIMITERS) {}

Tokenizer::Tokenizer(const std::string& s, const std::string& delimiters) :
    m_string(s), 
    m_offset(0), 
    m_delimiters(delimiters) {}

bool Tokenizer::NextToken() 
{
    return NextToken(m_delimiters);
}

bool Tokenizer::NextToken(const std::string& delimiters) 
{
    size_t i = m_string.find_first_not_of(delimiters, m_offset);
    if (std::string::npos == i) 
    {
        m_offset = m_string.length();
        return false;
    }

    size_t j = m_string.find_first_of(delimiters, i);
    if (std::string::npos == j) 
    {
        m_token = m_string.substr(i);
        m_offset = m_string.length();
        return true;
    }

    m_token = m_string.substr(i, j - i);
    m_offset = j;
    return true;
}

示例：

std::vector <std::string> v;
Tokenizer s("split this string", " ");
while (s.NextToken())
{
    v.push_back(s.GetToken());
}

Answer 21

这是一个简单的仅 STL 解决方案（约 5 行！），使用 std::find 和 std::find_first_not_of 处理分隔符的重复（例如空格或句点）实例），以及前导和尾随分隔符：

#include <string>
#include <vector>

void tokenize(std::string str, std::vector<string> &token_v){
    size_t start = str.find_first_not_of(DELIMITER), end=start;

    while (start != std::string::npos){
        // Find next occurence of delimiter
        end = str.find(DELIMITER, start);
        // Push back the token found into vector
        token_v.push_back(str.substr(start, end-start));
        // Skip all occurences of the delimiter to find new start
        start = str.find_first_not_of(DELIMITER, end);
    }
}

现场尝试一下！

Answer 22

Boost具有强大的分割功能：boost::algorithm::split。

示例程序：

#include <vector>
#include <boost/algorithm/string.hpp>

int main() {
    auto s = "a,b, c ,,e,f,";
    std::vector<std::string> fields;
    boost::split(fields, s, boost::is_any_of(","));
    for (const auto& field : fields)
        std::cout << "\"" << field << "\"\n";
    return 0;
}

输出：

"a"
"b"
" c "
""
"e"
"f"
""

Answer 23

使用 regex_token_iterator 的解决方案：

#include <iostream>
#include <regex>
#include <string>

using namespace std;

int main()
{
    string str("The quick brown fox");

    regex reg("\\s+");

    sregex_token_iterator iter(str.begin(), str.end(), reg, -1);
    sregex_token_iterator end;

    vector<string> vec(iter, end);

    for (auto a : vec)
    {
        cout << a << endl;
    }
}

Answer 24

无意冒犯各位，但是对于这样一个简单的问题，你把事情搞得太复杂了。 使用 Boost 的原因有很多。 但对于这么简单的事情，就像用 20# 雪橇打苍蝇一样。

void
split( vector<string> & theStringVector,  /* Altered/returned value */
       const  string  & theString,
       const  string  & theDelimiter)
{
    UASSERT( theDelimiter.size(), >, 0); // My own ASSERT macro.

    size_t  start = 0, end = 0;

    while ( end != string::npos)
    {
        end = theString.find( theDelimiter, start);

        // If at end, use length=maxLength.  Else use length=end-start.
        theStringVector.push_back( theString.substr( start,
                       (end == string::npos) ? string::npos : end - start));

        // If at end, use start=maxSize.  Else use start=end+delimiter.
        start = (   ( end > (string::npos - theDelimiter.size()) )
                  ?  string::npos  :  end + theDelimiter.size());
    }
}

例如（对于 Doug 的情况），

#define SHOW(I,X)   cout << "[" << (I) << "]\t " # X " = \"" << (X) << "\"" << endl

int
main()
{
    vector<string> v;

    split( v, "A:PEP:909:Inventory Item", ":" );

    for (unsigned int i = 0;  i < v.size();   i++)
        SHOW( i, v[i] );
}

是的，我们可以让 split() 返回一个新向量，而不是传入一个向量。包装和重载很简单。 但根据我正在做的事情，我经常发现重用预先存在的对象比总是创建新对象更好。 （只要我不要忘记清空中间的向量！）

参考： http://www.cplusplus.com/reference/string/string/。

（我最初是在写对 Doug 问题的回复：C++ 字符串修改和提取基于分隔符（已关闭），但自从 Martin York 用此处的指针结束了该问题......我将概括我的代码。）

Answer 25

您可以使用流、迭代器和复制算法来相当直接地完成此操作。

#include <string>
#include <vector>
#include <iostream>
#include <istream>
#include <ostream>
#include <iterator>
#include <sstream>
#include <algorithm>

int main()
{
  std::string str = "The quick brown fox";

  // construct a stream from the string
  std::stringstream strstr(str);

  // use stream iterators to copy the stream to the vector as whitespace separated strings
  std::istream_iterator<std::string> it(strstr);
  std::istream_iterator<std::string> end;
  std::vector<std::string> results(it, end);

  // send the vector to stdout.
  std::ostream_iterator<std::string> oit(std::cout);
  std::copy(results.begin(), results.end(), oit);
}

Answer 26

使用strtok。 在我看来，没有必要围绕标记化构建一个类，除非 strtok 不能为您提供所需的内容。 也许不会，但在用 C 和 C++ 编写各种解析代码的 15 年多的时间里，我一直使用 strtok。 这是一个示例

char myString[] = "The quick brown fox";
char *p = strtok(myString, " ");
while (p) {
    printf ("Token: %s\n", p);
    p = strtok(NULL, " ");
}

一些注意事项（可能不适合您的需求）。 该字符串在此过程中被“破坏”，这意味着 EOS 字符被内联放置在分隔符位置中。 正确的使用可能需要您创建字符串的非常量版本。 您还可以在解析过程中更改分隔符列表。

在我看来，上面的代码比为其编写一个单独的类要简单得多，也更容易使用。 对我来说，这是该语言提供的功能之一，而且它做得很好、很干净。 它只是一个“基于C”的解决方案。 它很合适，很简单，而且您不必编写很多额外的代码:-)

Answer 27

另一种快速方法是使用 getline。 比如：

std::istringstream iss(str);
std::string s;

while (std::getline(iss, s, ' ')) {
  std::cout << s << std::endl;
}

如果你愿意，你可以创建一个简单的 split() 方法，返回一个 std::vector，这非常有用。

Answer 28

C++ 标准库算法普遍基于迭代器而不是具体容器。 不幸的是，这使得在 C++ 标准库中提供类似 Java 的 split 函数变得很困难，尽管没有人认为这会很方便。 但它的返回类型是什么？ std::vector>？ 也许吧，但随后我们被迫执行（可能是多余且昂贵的）分配。

相反，C++ 提供了大量基于任意复杂分隔符分割字符串的方法，但它们都没有像其他语言那样封装得很好。 多种方式填充整个博客文章< /a>.

最简单的是，您可以使用 std::string::find< 进行迭代/code> 直到您点击 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_iterator s，字符串流的内容也可以使用其迭代器范围构造函数复制到向量中。

多个库（例如 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{}
);

Answer 29

这是一个非常简单的：

#include <vector>
#include <string>

vector<string> split(const char *str, char c = ' ')
{
    std::vector<std::string> result;

    do
    {
        const char *begin = str;

        while(*str != c && *str)
            str++;

        result.push_back(std::string(begin, str));
    } while (0 != *str++);

    return result;
}

Answer 30

Boost tokenizer 类可以使这种事情变得相当简单简单：

#include <iostream>
#include <string>
#include <boost/foreach.hpp>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main(int, char**)
{
    string text = "token, test   string";

    char_separator<char> sep(", ");
    tokenizer< char_separator<char> > tokens(text, sep);
    BOOST_FOREACH (const string& t, tokens) {
        cout << t << "." << endl;
    }
}

针对 C++11 进行了更新：

#include <iostream>
#include <string>
#include <boost/tokenizer.hpp>

using namespace std;
using namespace boost;

int main(int, char**)
{
    string text = "token, test   string";

    char_separator<char> sep(", ");
    tokenizer<char_separator<char>> tokens(text, sep);
    for (const auto& t : tokens) {
        cout << t << "." << endl;
    }
}