C++ 如何实现拆分功能，从一行中拆分单词？

我想实现一个函数，它将

string

作为一行输入（通过

getline（）

）并在向量中分隔（拆分）单词。我试过这个：

vector<string> split(const string &s)
{
    vector<string> ret;
    int j = 0, i = 0; // j=="start word boundary", i=="end word boundary"
    while (i != s.size())
    {
        //get words
        while (i != s.size() && !isspace(s[i]))
        {
            i++;
        }
        //at least one word found (so the 'i' index is not at the beginning of string)
        if (!i)
        {
            ret.push_back(s.substr(j, i - j));
        }
        //now look for blanks
        j = i;
        //ignore blanks
        while (j != s.size() && isspace(s[j]))
        {
            j++;
        }
        //get position for next words back
        i = j;
    }
    return ret;
}

向量拆分（常量字符串&s）
{
向量ret；
int j=0，i=0；//j==“开始字边界”，i==“结束字边界”
而（i！=s.size（））
{
//获得话语权
而（i！=s.size（）&&！isspace（s[i]））
{
i++；
}
//至少找到一个单词（因此“i”索引不在字符串的开头）
如果（！i）
{
后推（s.substr（j，i-j））；
}
//现在寻找空白
j=i；
//忽略空白
而（j！=s.size（）&&isspace（s[j]））
{
j++；
}
//获取下一个单词的位置
i=j；
}
返回ret；
}

然后尝试查看结果：

int main()
{
    string tmp;
    while (getline(cin, tmp))
    {
        vector<string> vec = split(tmp);
        for (string s : vec)
        {
            cout << s << endl;
        }
    }
}

intmain（）
{
串tmp；
while（getline（cin、tmp））
{
向量向量=分割（tmp）；
for（字符串s:vec）
{
您是否有一个输入错误：

if (!i)
{
   ret.push_back(s.substr(j, i - j));
}

仅当结束索引为
0
时才添加子字符串，但这意味着您从未向向量添加子字符串

相反，如果结束索引不是0，则需要添加子字符串：

下面是一个例子。
试试类似的方法：

向量拆分（常量字符串&s）
{
向量ret；
size\u t size=s.size（），开始=0，结束；
做
{
//跳过前导空格
while（start

然后可以通过使用
std:：string:：find_first（\u not）_of（）
将其简化一点，例如：

static const char*ws=“\t”；
向量拆分（常量字符串和s）
{
向量ret；
size\u t size=s.size（），开始=0，结束；
while（（start=s.find_first_not_of（ws，end））！=string:：npos）
{
if（（end=s.find_first_of（ws，start+1））==string:：npos）{
后推（s.substr（启动））；
打破
}
后推（s.substr（开始，结束-开始））；
开始=结束；
}
返回ret；
}

不过，将
std:：istringstream
与
operator>
一起使用会更简单：

。。。
#包括
向量拆分（常量字符串和s）
{
向量ret；
istringstream iss（s）；
字符串字；
while（iss>>word）{
向后推（字）；
}
返回ret；
}

或者，不使用手动循环：

。。。
#包括
#包括
#包括
向量拆分（常量字符串和s）
{
向量ret；
istringstream iss（s）；
复制（istream_迭代器（iss），istream_迭代器（），back_插入器（ret））；
返回ret；
}
A
std:：istringstream
对于此任务非常有用。只需说一句。关于您的代码，
split2
！=
split
，所以从那开始。我建议您阅读函数
std:：string:：first\u of
和
std:：string:：first\u of。例如，您可以定义字符串中的空白字符，并使用
std:：string:：first_not_of查找非空白的位置“@ThomasMatthews谢谢，我会查的。这只是一个通过索引和
substr
实现它的执行，没有迭代器。谢谢，我想确定的是，“I”不是0，但这与我写的相反。很多thanks@milanHrabos如果（i！=0）

if (i)   // if (i != 0)
{
   ret.push_back(s.substr(j, i - j));
}