C/C++编程：切割字符串总结

￡神魔★判官ぃ 2023-02-23 08:21 11阅读 0赞

# 封装 #

## 源码 ##

//
    // Created by oceanstar on 2021/8/11.
    //
    
    #ifndef OCEANSTAR_HTTP_ACL_ARGV_H
    #define OCEANSTAR_HTTP_ACL_ARGV_H
    
    #include <vector>
    #include <string>
    #include <string.h>
    
    namespace oceanstar{
        
        typedef struct ACL_ARGV {
        
            int     argc{
        };			/**< array elements in use */
            std::vector<std::string> argv;			/**< string array */
        } ACL_ARGV;
    
        inline ACL_ARGV * acl_argv_alloc(){
        
            return new ACL_ARGV();
        }
        inline void acl_argv_free(ACL_ARGV * argv){
        
            delete argv;
        }
    
        /**
         * 将给定字符串用另一个分隔符字符串进行分割
         * @param src {char**} 需要被分割的字符串的地址的指针，必须是非空指针，
         *  可以是空字符串，此时该函数返回 NULL
         * @param sep {const char*} 分隔符，非空字符串
         * @return {char*} 当前被分割的字符串的指针位置，src 指向下一个将要进行
         *  分隔的起始位置；
         *  1）当返回 NULL 时，则表示分隔过程结束，此时 src 的指针位置被赋予 '\0'；
         *  2）当返回非 NULL 时，则此时 src 指向的字符串可能是或不是空字符串，
         *     如果指向空字符串，则再次分隔时函数肯定能返回 NULL，否则，当再次分隔时
         *     函数返回非 NULL 指针
         *  举例: 源字符串："abcd=|efg=|hijk", 分隔符 "=|"，则第一次分隔后
         *  src 将指向 "efg"，而返回的地址为 "abcd"
         */
         inline char *acl_strtok(char **src, const char *sep){
        
            char   *start = *src;
            char   *end;
    
            /*
             * Skip over leading delimiters.
             */
            start += strspn(start, sep);
            if (*start == 0) {
        
                *src = start;
                return 0;
            }
    
            /*
             * Separate off one token.
             */
            end = start + strcspn(start, sep);
            if (*end != 0)
                *end++ = 0;
            *src = end;
            return start;
        }
    
        inline  ACL_ARGV * acl_argv_split(const char *str, const char *delim){
        
            ACL_ARGV *argvp = acl_argv_alloc();
            char   *saved_string = strdup(str);
            char   *bp = saved_string;
            char   *arg;
    
            while ((arg = acl_strtok(&bp, delim)) != 0){
        
                argvp->argv.emplace_back(arg);
            }
            argvp->argc = argvp->argv.size();
            free(saved_string);
            return argvp;
        }
    }
    
    
    #endif //OCEANSTAR_HTTP_ACL_ARGV_H

![在这里插入图片描述][ba3339ce775e4f209947c30a1aa588e4.png]

## 测试 ##

int main(void){
        
        oceanstar::ACL_ARGV* tokens =  oceanstar::acl_argv_split("127.0.0.1:7777:50;192.168.1.1:7777:10;127.0.0.1:7778", ";");
        std::string  addr;
        for(const auto& iter : tokens->argv){
        
            const char* ptr = iter.c_str();
            logger_info("server addr [%s]", ptr);
        }
        acl_argv_free(tokens);
        return 0;
    }

--------------------

# strchr() strncpy()根据某个字符切割字符串 #

#include <stdlib.h>
    #include <string.h>
    #include <stdio.h>
    
    void splitString(char* p1, char c, char buffer[10][30], int *count) {
        
        char* p = NULL, *pTmp = NULL;
        int tempCount = 0;
        p = p1;
        pTmp = p1;
    
        while (*p != '\0'){
        
            p = strchr(p, c); //检查符合条件的位置p 后移
            if (p != NULL){
        
                if (p-pTmp>0){
        
                    strncpy(buffer[tempCount],pTmp,p-pTmp);
                    buffer[tempCount][p - pTmp] = '\0';//变成C风格的字符串
                    tempCount++;
                    pTmp = p = p + 1;
                }
            }else{
        
                break;
            }
        }
        *count = tempCount;//具体有几个分割的字符串
        return ;
    }
    
    
    void main() {
        
        int  i = 0;
        char *p1 = "abcdef,acccd,bddddfdf,ffff,kjkjlkjkl";
        char splitC = ',';
        int nCout;
        char myArray[10][30];
        splitString(p1, splitC, myArray, &nCout);
        for (i = 0; i < nCout; i++) {
        
            printf("%s\n", myArray[i]);
        }
    
        system("pause");
    }

# 用strtok函数进行字符串分割 #

原型： char \*strtok(char \*str, const char \*delim);

功能：分解字符串为一组字符串。

参数说明：str为要分解的字符串，delim为分隔符字符串。

返回值：从str开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。

其它：strtok函数线程不安全，可以使用strtok\_r替代。

//借助strtok实现split
    #include <string.h>
    #include <stdio.h>
    
    int main()
    {
        
        char s[] = "Golden Global   View,disk * desk";
        const char *d = " ,*";   // 以' '， ','，'*'这三个字符切割
        char *p;
        p = strtok(s,d);
        while(p)
        {
        
            printf("%s\n",p);
            p=strtok(NULL,d);
        }
    
        return 0;
    }

![在这里插入图片描述][20210312101811183.png]

# 用STL进行字符串的分割 #

涉及到string类的两个函数find和substr：

*  1、find函数  
    原型：size\_t find ( const string& str, size\_t pos = 0 ) const;  
    功能：查找子字符串第一次出现的位置。  
    参数说明：str为子字符串，pos为初始查找位置。  
    返回值：找到的话返回第一次出现的位置，否则返回string::npos
 *  2、substr函数  
    原型：string substr ( size\_t pos = 0, size\_t n = npos ) const;  
    功能：获得子字符串。  
    参数说明：pos为起始位置（默认为0），n为结束位置（默认为npos）  
    返回值：子字符串

#include <iostream>
    #include <string>
    #include <vector>
     
    //字符串分割函数
    std::vector<std::string> split(std::string str,std::string pattern)
    {
        
      std::string::size_type pos;
      std::vector<std::string> result;
      str+=pattern;//扩展字符串以方便操作
      int size=str.size();
     
      for(int i=0; i<size; i++)
      {
        
        pos=str.find(pattern,i);
        if(pos<size)
        {
        
          std::string s=str.substr(i,pos-i);
          result.push_back(s);
          i=pos+pattern.size()-1;
        }
      }
      return result;
    }
     
    int main()
    {
        
      std::string str;
      std::cout<<"Please input str:"<<std::endl;
      //std::cin>>str;
      getline(std::cin,str);
      std::string pattern;
      std::cout<<"Please input pattern:"<<std::endl;
      //std::cin>>pattern;
      getline(std::cin,pattern);//用于获取含空格的字符串
      std::vector<std::string> result=split(str,pattern);
      std::cout<<"The result:"<<std::endl;
      for(int i=0; i<result.size(); i++)
      {
        
        std::cout<<result[i]<<std::endl;
      }
     
      std::cin.get();
      std::cin.get();
      return 0;
    }

# 用Boost进行字符串的分割 #

*  boost自带的split切割

#include <iostream>
    #include <string>
    #include <vector>
    #include <boost/algorithm/string/classification.hpp>
    #include <boost/algorithm/string/split.hpp>
      
    using namespace std;
      
    int main()
    {
        
     string s = "sss/ddd,ggg";
     vector<string> vStr;
     boost::split( vStr, s, boost::is_any_of( ",/" ), boost::token_compress_on );
     for( vector<string>::iterator it = vStr.begin(); it != vStr.end(); ++ it )
      cout << *it << endl;
     return 0;
    }

*  自己实现

#include <iostream>
    #include <cassert>
    #include <vector>
    #include <string>
    #include "boost/regex.hpp"
     
    std::vector<std::string> split(std::string str,std::string s)
    {
        
        boost::regex reg(s.c_str());
        std::vector<std::string> vec;
        boost::sregex_token_iterator it(str.begin(),str.end(),reg,-1);
        boost::sregex_token_iterator end;
        while(it!=end)
        {
        
            vec.push_back(*it++);
        }
        return vec;
    }
    int main()
    {
        
        std::string str,s;
        str="sss/ddd/ggg/hh";
        s="/";
        std::vector<std::string> vec=split(str,s);
        for(int i=0,size=vec.size();i<size;i++)
        {
        
            std::cout<<vec[i]<<std::endl;
        }
        std::cin.get();
        std::cin.get();
        return 0;
    }

[ba3339ce775e4f209947c30a1aa588e4.png]: https://img-blog.csdnimg.cn/ba3339ce775e4f209947c30a1aa588e4.png
[20210312101811183.png]: https://img-blog.csdnimg.cn/20210312101811183.png