zoukankan      html  css  js  c++  java
  • 分割字符串,字符串去除空格

     开始

    ```
    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 << '
    ';
            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;
    }
    View Code

    还有 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]) != '')
        {
            ++j;
            if (s[i] != ' ')
                ++i;
        }
    }

    --------------------------------------  2020-10-17  -------------------------------------

    //---------------------------------------------------------------------------------------
    // 功能:分割字符串,保留空字符串"",前向分割。(char* 版)
    // 参数:str 待分割的字符串,delim 分隔符(所有delim中包含的每个字符都是分隔符),vRet 返回分割后的结果
    // 例如:"0hello world0.00", " 0" --> "" "hello" "world" "." ""
    //---------------------------------------------------------------------------------------
    void split1(const char* str, const char* delim, std::vector<std::string> &vRet)
    {
        if (NULL == str || NULL == delim || '' == *str || '' == *delim)
            return;
        if (NULL == strpbrk(str, delim))//若一个都delim没有查到,就直接返回
            return;
        const int nLen = strlen(str);
        const char* p = str;
        const char* q = NULL;
        while (p < str + nLen)
        {
            q = strpbrk(p, delim);
            if (q != NULL)
            {
                vRet.push_back(std::string(p, q));
                p = q + 1;
            }
            else
            {
                vRet.push_back(std::string(p));
                break;
            }
        }
    }
    
    //---------------------------------------------------------------------------------------
    // 功能:分割字符串,保留空字符串"",前向分割。(wchar_t* 版)
    // 参数:str 待分割的字符串,delim 分隔符(所有delim中包含的每个字符都是分隔符),vRet 返回分割后的结果
    // 例如:"0hello world0.00", " 0" --> "" "hello" "world" "." ""
    //---------------------------------------------------------------------------------------
    void split1(const wchar_t* str, const wchar_t* delim, std::vector<std::wstring> &vRet)
    {
        if (NULL == str || NULL == delim || '' == *str || '' == *delim)
            return;
        if (NULL == wcspbrk(str, delim))//若一个都delim没有查到,就直接返回
            return;
        const int nLen = wcslen(str);
        const wchar_t* p = str;
        const wchar_t* q = NULL;
        while (p < str + nLen)
        {
            q = wcspbrk(p, delim);
            if (q != NULL)
            {
                vRet.push_back(std::wstring(p, q));
                p = q + 1;
            }
            else
            {
                vRet.push_back(std::wstring(p));
                break;
            }
        }
    }
    
    
    //---------------------------------------------------------------------------------------
    // 功能:分割字符串(整体作为一个分隔符),保留空字符串"",前向分割。(char* 版)
    // 参数:str是待分割的字符串 delim整体作为一个分隔符,vRet 返回分割后的结果
    // 例如:"00hello00world0.00", "00" --> "" "hello" "world0."
    //---------------------------------------------------------------------------------------
    void split2(const char* str, const char* delim, std::vector<std::string> &vRet)
    {
        if (NULL == str || NULL == delim || '' == *str || '' == *delim)
            return;
        if (NULL == strstr(str, delim))//若一个都delim没有查到,就直接返回
            return;
        const int nLen = strlen(str);
        const int n = strlen(delim);
        const char* p = str;
        const char* q = NULL;
        while (p < str + nLen)
        {
            q = strstr(p, delim);
            if (q != NULL)
            {
                vRet.push_back(std::string(p, q));
                p = q + n;
            }
            else
            {
                vRet.push_back(std::string(p));
                break;
            }
        }
    }
    
    //---------------------------------------------------------------------------------------
    // 功能:分割字符串(整体作为一个分隔符),保留空字符串"",前向分割。(wchar_t* 版)
    // 参数:str是待分割的字符串 delim整体作为一个分隔符,vRet 返回分割后的结果
    // 例如:"00hello00world0.00", "00" --> "" "hello" "world0."
    //---------------------------------------------------------------------------------------
    void split2(const wchar_t* str, const wchar_t* delim, std::vector<std::wstring> &vRet)
    {
        if (NULL == str || NULL == delim || '' == *str || '' == *delim)
            return;
        if (NULL == wcsstr(str, delim))//若一个都delim没有查到,就直接返回
            return;
        const int nLen = wcslen(str);
        const int n = wcslen(delim);
        const wchar_t* p = str;
        const wchar_t* q = NULL;
        while (p < str + nLen)
        {
            q = wcsstr(p, delim);
            if (q != NULL)
            {
                vRet.push_back(std::wstring(p, q));
                p = q + n;
            }
            else
            {
                vRet.push_back(std::wstring(p));
                break;
            }
        }
    }
    
    
    //---------------------------------------------------------------------------------------
    // 分割字符串str,pattern中的每个字符都是分隔符,前向分割。(std::string 版)
    // 例如:"0hello world0.00", " 0" --> "" "hello" "world" "." ""
    //---------------------------------------------------------------------------------------
    void split1(const string& str, const string& pattern, vector<string>& ret)
    {
        if (pattern.empty() || str.empty())
            return;
        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);
        }
        if (start < str.size())
            ret.push_back(str.substr(start));
    }
    //---------------------------------------------------------------------------------------
    // 分割字符串str,pattern中的每个字符都是分隔符,前向分割。(std::wstring 版)
    // 例如:"0hello world0.00", " 0" --> "" "hello" "world" "." ""
    //---------------------------------------------------------------------------------------
    void split1(const std::wstring& str, const std::wstring& pattern, vector<std::wstring>& ret)
    {
        if (pattern.empty() || str.empty())
            return;
        size_t start = 0;
        size_t index = str.find_first_of(pattern, 0);
        while (index != std::wstring::npos)
        {
            ret.push_back(str.substr(start, index - start));
            start = index + 1;
            index = str.find_first_of(pattern, start);
        }
        if (start < str.size())
            ret.push_back(str.substr(start));
    }
    
    //---------------------------------------------------------------------------------------
    // 分割字符串str,pattern整体做为一个分隔符,前向分割。(std::string 版)
    // 例如:"00hello00world0.00", "00" --> "" "hello" "world0."
    //---------------------------------------------------------------------------------------
    void split2(const string& str, const string& pattern, vector<string>& ret)
    {
        if (pattern.empty() || str.empty())
            return;
        size_t nLen = pattern.size();
        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 + nLen;
            index = str.find(pattern, start);
        }
        if (start < str.size())
            ret.push_back(str.substr(start));
    }
    //---------------------------------------------------------------------------------------
    // 分割字符串str,pattern整体做为一个分隔符,前向分割。(std::wstring 版)
    // 例如:"00hello00world0.00", "00" --> "" "hello" "world0."
    //---------------------------------------------------------------------------------------
    void split2(const std::wstring& str, const std::wstring& pattern, vector<std::wstring>& ret)
    {
        if (pattern.empty() || str.empty())
            return;
        size_t nLen = pattern.size();
        size_t start = 0;
        size_t index = str.find(pattern, 0);
        while (index != std::wstring::npos)
        {
            ret.push_back(str.substr(start, index - start));
            start = index + nLen;
            index = str.find(pattern, start);
        }
        if (start < str.size())
            ret.push_back(str.substr(start));
    }

    常记溪亭日暮,沉醉不知归路。兴尽晚回舟,误入藕花深处。争渡,争渡,惊起一滩鸥鹭。

    昨夜雨疏风骤,浓睡不消残酒。试问卷帘人,却道海棠依旧。知否?知否?应是绿肥红瘦。
  • 相关阅读:
    vue 中 过滤filter 和 foreach的使用
    vuex 获取数据
    动态设置样式 calc计算
    vue-echarts-v3 使用 dataZoom属性 相关笔记
    访存加速-Speed-up of Memory Access Intensive Program
    台式机新添内存条无法开机?
    ADB的版本问题
    1184. Distance Between Bus Stops
    485. Max Consecutive Ones
    448. Find All Numbers Disappeared in an Array
  • 原文地址:https://www.cnblogs.com/htj10/p/11354618.html
Copyright © 2011-2022 走看看