分割字符串，字符串去除空格

```
find() : Finds the first substring equal to the given character sequence
find_first_of() : Finds the first character equal to one of characters in the given character sequence
//字符串分割函數 str為待分割的字符串 pattern為任意分割符(**每一個字符都為分割符**)，例如：";,"是以 ';' 和 ',' 分割，並且去掉了分割后的空字符串。 sbcssdfs 以s分割得 "bc" "df"
vector<string> split(string str, string pattern)
{
    vector<string> ret;
    if (pattern.empty()) return ret;
    size_t start = 0;
    size_t index = str.find_first_of(pattern, 0);
    while (index != string::npos)
    {
        if (start != index)
            ret.push_back(str.substr(start, index - start));
        start = index + 1;
        index = str.find_first_of(pattern, start);
    }
 
    if (!str.substr(start).empty())
        ret.push_back(str.substr(start));
    return ret;
}
//分割后保留空字符串。sbcssdfs 以s分割得 "" "bc" "" "df" ""
vector<string> split(string str, string pattern)
{
    vector<string> ret;
    if (pattern.empty()) return ret;
    size_t start = 0;
    size_t index = str.find_first_of(pattern, 0);
    while (index != string::npos)
    {
        ret.push_back(str.substr(start, index - start));
        start = index + 1;
        index = str.find_first_of(pattern, start);
    }
    ret.push_back(str.substr(start));
    return ret;
}
```
用Poco中的StringTokenizer
```
#include "Poco/StringTokenizer.h"
#include "Poco/String.h" // for cat
// 分割字符串，s:將被分割的字符串，k：分割符
// 例如： k是 ";,"表示用 ';' 和 ',' 分割
std::vector<std::string> SplitString(std::string s, std::string k)
{
    /*
    Poco::StringTokenizer t1("red, green, blue", ",");
    // "red", " green", " blue"     (note the whitespace)
    Poco::StringTokenizer t2("red,green,,blue", ",");
    // "red", "green", "", "blue"
    Poco::StringTokenizer t3("red ; green , blue", ",;",
        Poco::StringTokenizer::TOK_TRIM);
    // "red", "green", "blue"
    Poco::StringTokenizer t4("red; green,, blue", ",;",
        Poco::StringTokenizer::TOK_TRIM | Poco::StringTokenizer::TOK_IGNORE_EMPTY);
    // "red", "green", "blue"
    std::string ss(Poco::cat(std::string("; "), t4.begin(), t4.end()));
    // "red; green; blue
    */
    Poco::StringTokenizer st(s, k);//這樣是不去掉 "" ,當加上 TOK_IGNORE_EMPTY（宏定義為1）即去掉 "" 了。
    std::vector<std::string> vecRet(st.begin(), st.end());
    return vecRet;
}
```
另外一個字符串整體為分割符：（單個字符就跟上面的一樣了）
```
//pattern作為一個整體當分割符,(不去掉 "")
vector<string> split(string str, string pattern)
{
    vector<string> ret;
    if (pattern.empty()) return ret;
    size_t start = 0;
    size_t index = str.find(pattern, 0);
    while (index != string::npos)
    {
        ret.push_back(str.substr(start, index - start));
        start = index + pattern.size();
        index = str.find(pattern, start);
    }
    ret.push_back(str.substr(start));
    return ret;
}
```

 另外，有strtok

char *strtok(char s[], const char *delim);
wchar_t *wcstok(wchar_t s[], const wchar_t *delim)
_tcstok() 對應 TCHAR 的函數

分解字符串為一組字符串。s為要分解的字符串，delim為分隔符字符串。strtok函數會破壞被分解字符串的完整，調用前和調用后的s已經不一樣了。

#pragma warning (disable : 4996)
int main()
{
    char s[] = "this is. 192...168.0.1..";
    char *token = strtok(s, " .");//以空格和“.”進行分割，並且不保留空字符串
    while (token)
    {
        cout << token << '\n';
        token = strtok(NULL, " .");
        //_tcstok()
    }
    return 0;
}//結果： this is 192 168 0 1

用其實現的split函數

// delim分隔符，所有delim中包含的字符都是分隔符，且不保留空字符串""
#pragma warning (disable : 4996)
std::vector<std::string> split(char* s, const char* delim)
{
    std::vector<std::string> vecRet;
    char* token = strtok(s, delim);
    while (token)
    {
        vecRet.push_back(std::string(token));
        token = strtok(NULL, delim);
    }
    return vecRet;
}

std::vector<CString> split(TCHAR* s, const TCHAR* delim)
{
    std::vector<CString> vecRet;
    TCHAR* token = _tcstok(s, delim);
    while (token)
    {
        vecRet.push_back(CString(token));
        token = _tcstok(NULL, delim);
    }
    return vecRet;
}

 

還有 CString的 Tokenize()

原型：

CStringT Tokenize( PCXSTR pszTokens , int& iStart ) const;

功能：

從iStart位置取出字符串中含pszTokens分割符間的內容；

參數

pszTokens:包含標記分隔符的字符串。 這些分隔符順序並不重要。

iStart:開始搜索的從零開始的索引。

返回值

包含當前標記值的 CStringT 對象。

備注 ：

將 pszTokens 的字符指定將找到的標記可能的分隔符。 在每次調用Tokenize函數開始對 iStart，導致分隔符的"跳過"，並返回包含當前標記的CStringT對 象，是字符串到下分隔符。如果該字符串的末尾已到達，更新 iStart 的值為后面的位置關閉分隔符的或-1。 多個標記中打開目標字符串的其余部分由一系列調用Tokenize，使用 iStart 記錄在字符串下一個標記要讀取的位置。 當沒有更多的標記函數返回一個空字符串，並 iStart 將設置為-1。　Tokenize不修改目標字符串。

// delim分隔符，所有delim中包含的字符都是分隔符，且不保留空字符串""
std::vector<CString> split(const CString& str, const CString& delim)
{
    std::vector<CString> vecRet;
    const int nLen = str.GetLength();
    int pos = 0;
    CString s;
    while ((s = str.Tokenize(delim, pos)) != _T(""))
    {
        vecRet.push_back(s);
    }
    return vecRet;
}

 使用C語言風格的字符串函數，<string.h>或<cstring>

 char* strstr(const char* p, const char* q)
在字符串p中查找第一次出現字符串q的位置，返回指向他的指針，否則返回NULL
char* strpbrk(const char* p, const char* p1)
在p指向的字符串中查找第一次出現p1指向的字符串中任何字符的位置。成功返回p中指向該字符的指針，失敗返回NULL。

// delim分隔符，所有delim中包含的字符都是分隔符，保留空字符串"",前向分割
void split(const char* str, const char* delim, std::vector<std::string> &vRet)
{
    const char* p = str;
    const char* q = NULL;
    while (*p && (q = strpbrk(p, delim)))
    {
        vRet.push_back(std::string(p, q));
        ++q;
        p = q;
    }
    if (*p)
        vRet.push_back(std::string(p));
}

int main()
{
    char s[] = "...this is. 192..";
    char d[] = ". ";
    std::vector<std::string> vRet;
    split(s, d, vRet);//Result: "" "" "" "this" "is" "" "192" ""
    return 0;
}

 

// str是待分割的字符串 delim整體作為一個分隔符，保留空字符串"",前向分割
void split(const char* str, const char* delim, std::vector<std::string> &vRet)
{
    const int n = strlen(delim);
    const char* p = str;
    const char* q = NULL;
    while (*p && (q = strstr(p, delim)))
    {
        vRet.push_back(std::string(p, q));
        q = q + n;
        p = q;
    }
    if (*p)
        vRet.push_back(std::string(p));
}

int main()
{
    char s[] = "...this is. 192..";
    char d[] = ". ";
    std::vector<std::string> vRet;
    split(s, d, vRet);//Result: "...this is" "192.."
    return 0;
}

 

字符串去除空格

void eatspaces(char* s)
{
    int i = 0;
    int j = 0;
    while ((s[i] = s[j]) != '\0')
    {
        ++j;
        if (s[i] != ' ')
            ++i;
    }
}