我们知道，ASCII编码的13表示回车('\r')、10表示换行('\n')，在一些库的文本框中可能需要两个符号“\r\n“写在一起来表示换行，在C++中，可以只用'\n'来表示换行。

对于字符串按行或按某个字符进行分割，C++标准库里面并没有提供字符分割函数split()（cstring中有strtok()函数，但较底层），需要自行定义。

1 string+vector逐字节处理

在一个多行文本（有多个'\n'）中，如果想要分行处理，可以逐个字符分析，将其叠加写入一个临时的string，直到遇到'\n'，然后push_back入一vector，再套一个循环即可：

vector<string> split0(string str,char deli) // string+vector逐字节处理
{
    vector<string> vec;
    string tmp;
    string::iterator it=str.begin();
    for(; it != str.end();it++)
    {
        if (*it != deli)
            tmp += *it;
        else
        {
            vec.push_back(tmp);
            tmp = "";
        }
    }
    return vec;
}

2 利用strtok()分割

先看strtok()的函数原型：

char * strtok ( char * str, const char * delimiters );

对此函数的一系列调用将str拆分为标记（tokens），这些标记是由作为分隔符一部分的任何字符分隔的连续字符序列。

在第一次调用时，函数需要一个C字符串作为str的参数，str的第一个字符用作扫描标记的起始位置。在随后的调用中，函数需要一个空指针，并使用最后一个标记结束后的位置作为新的扫描起始位置。

要确定标记的开始和结束，函数首先从开始位置扫描分隔符中未包含的第一个字符（它将成为标记的开始）。然后从标记的开头开始扫描分隔符中包含的第一个字符，该字符将成为标记的结尾。如果找到终止的空字符，扫描也会停止。

标记的末端替换为空字符，并且该函数返回标记的开头。

一旦在对strtok的调用中找到str的终止空字符，对该函数的所有后续调用（以空指针作为第一个参数）都将返回空指针。

找到最后一个标记的点由下一次调用时使用的函数内部保存（不需要特定的库实现来避免数据竞争）。

请注意的是，第一个参数是要截断的C字符串，因为是址传递，所以存在副作用，这个字符串是通过分成更小的字符串（标记）来修改的。

另外，可以指定空指针，在这种情况下，函数继续扫描先前对函数的成功调用结束的位置。

返回值：

如果找到标记，则指向标记开头的指针。否则，为空指针。

当扫描的字符串到达字符串的末尾（即空字符）时，总是返回空指针。

vector<string> split1(char* src,const char* separator)  // 利用strtok()分割   // 分隔符可以指定多个
{
	if (strlen(src) ==  0)
		exit(0);
	vector<string> vec;
	char *pNext = (char *)strtok(src,separator); 
	while(pNext != NULL) 
	{
		vec.push_back(pNext);
		pNext = (char *)strtok(NULL,separator);
	}  
	return vec;
} 

完全用C写更繁琐：

int splitc(char *src,const char *separator,char **dest)  // 完全按C代码写
{
     char *pNext;
     int count = 0;
     if (src == NULL || strlen(src) == 0)
        return 0;
     if (separator == NULL || strlen(separator) == 0)
        return 0;
     pNext = (char *)strtok(src,separator);
     while(pNext != NULL) {
          *dest++ = pNext;
          ++count;
         pNext = (char *)strtok(NULL,separator);
    }  
    return count;
} 
void Print(char **ppstr, int num)
{
	for(int i = 0;i < num; i ++) {
		printf("%s\n",ppstr[i]);
	}
}
void test()
{
	char *buf[3] = {0};
	char str2[] = "知善知恶\n为善去恶\n知行合一";
	splitc(str2,"\n",buf);
	Print(buf,3);
}

3 .find_first_of()+substr()逐段处理

find_first_of()方法的函数原型：

size_t find_first_of (const string& str, size_t pos = 0) const;
size_t find_first_of (const char* s, size_t pos = 0) const;
size_t find_first_of (const char* s, size_t pos, size_t n) const;
size_t find_first_of (char c, size_t pos = 0) const;

用于在字符串中搜索与参数中指定的任何字符匹配的第一个字符。

当指定pos时，搜索仅包括pos位置处或之后的字符，忽略pos之前可能出现的任何字符。

Notice that it is enough for one single character of the sequence to match (not all of them). See string::find for a function that matches entire sequences.

需要注意的是，序列中的一个字符（不是所有字符）就足够匹配了。有关匹配整个序列的函数，请参见string::find。

vector<string> split2(string str, string delis) // .find_first_of()+substr()
{
	vector<string> vec;
	size_t current;
	size_t next = -1;
	do{
		current = next + 1;
		next = str.find_first_of(delis, current);
		vec.push_back(str.substr(current, next - current));
	}while(next != string::npos);
	return vec;
}

4 string+vector逐段处理

可以利用string的find()、substr()、erase()来处理：

vector<string> split3(string str,char del) // string+vector逐段处理
{
    vector<string> vec;
    string line;
	int pos = str.find(del);
	while(pos != string::npos)
	{
	    line = str.substr(0,pos);
		vec.push_back(line);
	    str.erase(0,pos+1);
		pos = str.find(del);
	}
    return vec;
}

5 利用getline()函数分割

也可以利用getline()函数，其原型（利用重载有两个版本）：

istream& getline ( istream &is , string &str , char delim ); // ①
istream& getline (istream& is, string& str);                        // ②

从输入流is中逐个提取字符直到分隔符delim出现（上述②为'\n'）为止，保存到str，流指针自移动。

每个提取的字符都被追加到字符串str中，就好像它的成员push_back被调用一样。

如果在is中到达文件结尾或在输入操作期间发生其他错误，则提取也将停止。

如果找到分隔符，则提取并丢弃它（即它未被存储，下一个输入操作将在它之后开始，因为输入流指针的自移动）。

需要注意的是，在调用之前str中的任何内容都将被新提取的序列替换。

getline可返回eofbit、failbit、badbit，用于判断字符串提取状态。

上述的输入流可以是cin，如

	string str;
	while (getline(cin, str, '#'))
	    cout << str<< endl;

也可以是继承自istream的istringstream、ifstream。

相对于cin，istringstream、ifstream流在内部维护了一个可自移动的输入流指针，用于持续提取及于判断是否到了输入流末端。

5.1 字符串流+string+vector处理

vector<string> split(string str, char deli)  // 字符串流+string+vector处理
{
    stringstream ss(str);
    string tmp;
    vector<string> vec;
    while(getline(ss, tmp, deli)) 
        vec.push_back(tmp);
    return vec;
}

可以写成更规范的模板函数：

struct split
{
  enum empties_t { empties_ok, no_empties };
};

template <typename Container>
Container& splitt(
    Container&    box,
    const typename Container::value_type&      s,
    typename Container::value_type::value_type deli,
    split::empties_t empties = split::empties_ok )
{
    box.clear();
    std::istringstream ss( s );
    while (!ss.eof())
    {
        typename Container::value_type field;
        getline(ss, field, deli);
        if((empties == split::no_empties) && field.empty()) 
			continue;
        box.push_back( field );
    }
    return box;
}

5.2 fstream+string+vector处理

vector<string> split(string str)   // fstream+string+vector处理
{
    ofstream ofs("tmp.txt");
	ofs<<str.c_str();
    ofs.close();
	ifstream ifs("tmp.txt");
	vector<string> vec;
	string tmp;
	while(getline(ifs,tmp))
		vec.push_back(tmp);
	//cout<<ifs.rdbuf();
	ifs.close();
    return vec;
}

综上：

序列为2的方法（strtok()）可以指定多个分隔符；

序列为5.1的方法（istringsteam）处理起来较简洁。

附完整源代码：

#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
using namespace std;

vector<string> split0(string str,char deli) // string+vector逐字节处理
{
    vector<string> vec;
    string tmp;
    string::iterator it=str.begin();
    for(; it != str.end();it++)
    {
        if (*it != deli)
            tmp += *it;
        else
        {
            vec.push_back(tmp);
            tmp = "";
        }
    }
    return vec;
}

vector<string> split1(char* src,const char* separator)  // strtok()，分隔符可以指定多个
{
    if (strlen(src) ==  0)
        exit(0);
    vector<string> vec;
    char *pNext = (char *)strtok(src,separator); 
    while(pNext != NULL) 
    {
        vec.push_back(pNext);
        pNext = (char *)strtok(NULL,separator);
    }  
    return vec;
} 

vector<string> split2(string str, string delimiters) // .find_first_of()+substr()
{
	vector<string> vec;
	size_t current;
	size_t next = -1;
	do
	{
		current = next + 1;
		next = str.find_first_of( delimiters, current );
		vec.push_back(str.substr( current, next - current ));
	}
	while (next != string::npos);
	return vec;
}

vector<string> split3(string str,char del) // string+vector逐段处理
{
    vector<string> vec;
    string line;
    int pos = str.find(del);
    while(pos != string::npos)
    {
        line = str.substr(0,pos);
        vec.push_back(line);
        str.erase(0,pos+1);
        pos = str.find(del);
    }
    return vec;
}

vector<string> split(string str, char del)  // 字符串流+string+vector处理
{
    stringstream ss(str);
    string temp;
    vector<string> ret;
    while (getline(ss, temp, del)) 
        ret.push_back(temp);
    return ret;
}

struct split
{
  enum empties_t { empties_ok, no_empties };
};

template <typename Container>
Container& splitt(
    Container&                                 result,
    const typename Container::value_type&      s,
    typename Container::value_type::value_type delimiter,
    split::empties_t                           empties = split::empties_ok )
{
    result.clear();
    std::istringstream ss( s );
    while (!ss.eof())
    {
        typename Container::value_type field;
        getline( ss, field, delimiter );
        if ((empties == split::no_empties) && field.empty()) continue;
        result.push_back( field );
    }
    return result;
}

vector<string> split(string str)   // fstream+string+vector处理
{
    ofstream ofs("tmp.txt");
    ofs<<str.c_str();
    ofs.close();
    ifstream ifs("tmp.txt");
    vector<string> vec;
    string tmp;
    while(getline(ifs,tmp))
        vec.push_back(tmp);
    //cout<<ifs.rdbuf();
    ifs.close();
    return vec;
}

void vectorPrint(vector<string>& vec)
{
    vector<string>::iterator vit=vec.begin();
    for(;vit!=vec.end();vit++)
        printf("%s\n", (*vit).c_str());
}

int main()
{
    string str  = "上善若水。\n水善利万物而不争，\n";
           str += "处众人之所恶，故几于道。\n";

    vector<string> vec = split0(str,'\n');
    vectorPrint(vec);

    string str1 = "We are the world!\nwe are the one!\n";;
    vec = split1(const_cast<char*>(str1.c_str()),"\r\n");
    vectorPrint(vec);
	
    vec = split2(str,"\n");
    vectorPrint(vec);

    vec = split3(str,'\n');
    vectorPrint(vec);

    vec = split(str,'\n');
    vectorPrint(vec);	

	//splitt(vec,str,'\n');
	//vectorPrint(vec);
	
    vec = split(str);
    vectorPrint(vec);

    cin.get();
    return 0;
}

/* output：
上善若水。
水善利万物而不争，
处众人之所恶，故几于道。
We are the world!
we are the one!
上善若水。
水善利万物而不争，
处众人之所恶，故几于道。

上善若水。
水善利万物而不争，
处众人之所恶，故几于道。
上善若水。
水善利万物而不争，
处众人之所恶，故几于道。
上善若水。
水善利万物而不争，
处众人之所恶，故几于道。

https://ask.csdn.net/questions/690685
https://blog.csdn.net/qq_36743440/article/details/91999615
http://www.cplusplus.com/reference/cstring/strtok/
http://www.cplusplus.com/faq/sequences/strings/split/
*/

－End－