C++ 拆分字符串

我有这个代码来分割一个字符串。出于某种原因，它只是坐在那里无所事事。我不确定是什么问题。顺便说一下，

delim='

这里

vector<string> split( const string &str, const char &delim )
{
    typedef string::const_iterator iter;

    iter beg = str.begin();

    vector<string> tokens;

    while(beg != str.end())
    {
        iter temp = find(beg, str.end(), delim);
        if(beg != str.end())
            tokens.push_back(string(beg, temp));
        beg = temp;
    }

    return tokens;
}

向量拆分（常量字符串和str、常量字符和delim）
{
typedef字符串：：常量迭代器iter；
iter beg=str.begin（）；
向量标记；
while（beg！=str.end（））
{
iter temp=find（beg，str.end（），delim）；
如果（beg！=str.end（））
回推（字符串（beg，temp））；
beg=温度；
}
归还代币；
}

find（）将返回下一个标记的位置X。然后，当您将其分配给beg并进入下一个迭代时，它将在位置X处开始一次又一次地搜索。。。i、 你陷入了一个无休止的循环

请尝试以下代码：

vector<string> split( const string &str, const char &delim )
{
    typedef string::const_iterator iter;

    vector<string> tokens;
    iter pos = str.begin(), last = str.begin();

    while(pos != str.end()) {
        last = pos;
        pos = find(pos, str.end(), delim);

        if (pos != str.end()) {
            string token = string(last, pos);
            if (token.length() > 0)
                tokens.push_back(token);

            last = ++pos;
        }
    }

    string lastToken = string(last, pos);
    if (lastToken.length() > 0)
        tokens.push_back(lastToken);

    return tokens;
}

向量拆分（常量字符串和str、常量字符和delim）
{
typedef字符串：：常量迭代器iter；
向量标记；
iter pos=str.begin（），last=str.begin（）；
while（pos！=str.end（））{
last=pos；
pos=find（pos，str.end（），delim）；
如果（pos！=str.end（））{
字符串标记=字符串（最后一个，位置）；
if（token.length（）>0）
代币。推回（代币）；
last=++pos；
}
}
字符串lastToken=字符串（最后一个，位置）；
if（lastToken.length（）>0）
代币。推回（lastToken）；
归还代币；
}

这样做的另一个好处是，它将包括列表中的最后一个令牌（例如，在空间上拆分时，字符串“a b c”现在将返回令牌a、b和c，而不仅仅是a和b），并且多个delim不会导致空令牌。

find（）将返回下一个令牌的位置X。然后，当您将其分配给beg并进入下一个迭代时，它将在位置X处开始一次又一次地搜索。。。i、 你陷入了一个无休止的循环

请尝试以下代码：

vector<string> split( const string &str, const char &delim )
{
    typedef string::const_iterator iter;

    vector<string> tokens;
    iter pos = str.begin(), last = str.begin();

    while(pos != str.end()) {
        last = pos;
        pos = find(pos, str.end(), delim);

        if (pos != str.end()) {
            string token = string(last, pos);
            if (token.length() > 0)
                tokens.push_back(token);

            last = ++pos;
        }
    }

    string lastToken = string(last, pos);
    if (lastToken.length() > 0)
        tokens.push_back(lastToken);

    return tokens;
}

向量拆分（常量字符串和str、常量字符和delim）
{
typedef字符串：：常量迭代器iter；
向量标记；
iter pos=str.begin（），last=str.begin（）；
while（pos！=str.end（））{
last=pos；
pos=find（pos，str.end（），delim）；
如果（pos！=str.end（））{
字符串标记=字符串（最后一个，位置）；
if（token.length（）>0）
代币。推回（代币）；
last=++pos；
}
}
字符串lastToken=字符串（最后一个，位置）；
if（lastToken.length（）>0）
代币。推回（lastToken）；
归还代币；
}

这样做的另一个好处是，它将包括列表中的最后一个令牌（例如，在空间上拆分时，字符串“abc”现在将返回令牌a、b和c，而不仅仅是a和b），并且多个delims不会导致空令牌。

我可以为您调试它，我想，但从长远来看，这对您没有帮助。这是你要做的

在每行之后，放置printf（）或cout statement，将更改的变量转储到标准输出。然后运行代码，向其传递一组简单的参数：

vector<string> x = split ("Hello there, Bob.", ' ');

如果在

while

循环结束时没有跳过空格的代码，则输出为：

:Hello, my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :

诸如此类，无穷无尽。通过跳过代码，您可以得到：

:Hello, my name is Bob. :
:my name is Bob. :
:name is Bob. :
:is Bob. :
:Bob. :

我想我可以帮你调试，但从长远来看，这对你没有帮助。这是你要做的

在每行之后，放置printf（）或cout statement，将更改的变量转储到标准输出。然后运行代码，向其传递一组简单的参数：

vector<string> x = split ("Hello there, Bob.", ' ');

如果在

while

循环结束时没有跳过空格的代码，则输出为：

:Hello, my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :
: my name is Bob. :

诸如此类，无穷无尽。通过跳过代码，您可以得到：

:Hello, my name is Bob. :
:my name is Bob. :
:name is Bob. :
:is Bob. :
:Bob. :

---

while循环中存在一个问题，即如果找到分隔符，则

temp

将指向第一次

find

调用后的第一个分隔符

在while循环结束时，将

beg

设置为

temp

的值

现在，

beg

也指向第一个分隔符

下次调用

find

时，它将再次返回

beg

的当前值，因为它指向一个分隔符

---

temp

没有从它以前的值移动，因此您处于无限循环中。

while循环中存在一个问题，即如果找到了分隔符，则

temp

将指向第一个

find

调用后的第一个分隔符

vector<string> split( const string &str, const char &delim )
{
    typedef string::const_iterator iter;

    iter beg = str.begin();

    vector<string> tokens;

    while(beg != str.end())
    {
        iter temp = find(beg, str.end(), delim);
        if(beg != str.end())
            tokens.push_back(string(beg, temp));
        if(temp != str.end())
            temp++;
        beg = temp;
    }

    return tokens;
}

在while循环结束时，将

beg

设置为

temp

的值

现在，

beg

也指向第一个分隔符

下次调用

find

时，它将再次返回

beg

的当前值，因为它指向一个分隔符

temp

没有从它的上一个值移动，因此您处于无限循环中。

向量拆分（const string&str，const char&delim）
vector<string> split( const string &str, const char &delim )
{
    typedef string::const_iterator iter;

    iter beg = str.begin();

    vector<string> tokens;

    while(beg != str.end())
    {
        iter temp = find(beg, str.end(), delim);
        if(beg != str.end())
            tokens.push_back(string(beg, temp));
        if(temp != str.end())
            temp++;
        beg = temp;
    }

    return tokens;
}

{
typedef字符串：：常量迭代器iter；
iter beg=str.begin（）；
向量标记；
while（beg！=str.end（））
{
iter temp=find（beg，str.end（），delim）；
如果（beg！=str.end（））
回推（字符串（beg，temp））；
如果（temp！=str.end（））
temp++；
beg=温度；
}
归还代币；
}

向量拆分（常量字符串和str、常量字符和delim）
{
typedef字符串：：常量迭代器iter；
iter beg=str.begin（）；
向量标记；
while（beg！=str.end（））
{
iter temp=find（beg，str.end（），delim）；
如果（beg！=str.end（））
回推（字符串（beg，temp））；
如果（temp！=str.end（））
temp++；
beg=温度；
}
归还代币；
}

调试此代码的最简单方法是打印

beg

将显示的所有位置。如果

beg

没有增加，那就是你的问题。

调试此代码的最简单方法是打印所有位置

beg

将要显示的位置。如果

beg

没有增加，那就是你的问题。

除了

beg

需要随着大小增加之外

std::vector<std::string> result;
boost::iter_split(result, str, 
    boost::first_finder(delim, boost::is_iequal()));