C++字符串分割方法详解

C++实现字符串分割的方法有多种，各有优劣。1. 使用std::string::find和substr：简单易懂但效率较低，适用于分隔符较少的情况；2. 使用std::getline：代码简洁、效率较高，但仅支持单字符分隔符；3. 使用Boost库的boost::split：功能强大、支持多分隔符和正则表达式，但需引入外部库；4. 使用C风格strtok函数：不推荐，线程不安全且会修改原始字符串；5. 处理空字符串可通过判断子串是否为空决定是否保留；6. 根据多个分隔符分割可使用正则表达式或Boost库；7. 性能优化可通过避免拷贝、使用std::string_view及预编译正则表达式等方式实现。选择合适方法取决于具体需求如分隔符复杂度、性能要求等。

C++实现字符串分割，本质上就是将一个字符串按照特定的分隔符拆分成多个子字符串。方法有很多，各有优劣，选择哪种取决于具体需求，例如分隔符的复杂程度、性能要求等。

解决方案

C++中实现字符串分割，主要有以下几种方法：

1. 使用std::string::find和std::string::substr： 这是最基础的方法，通过循环查找分隔符的位置，然后使用substr截取子字符串。

   

   #include 
   #include 
   #include 
   
   std::vector splitString(const std::string& str, const std::string& delimiter) {
       std::vector result;
       size_t start = 0;
       size_t end = str.find(delimiter);
       while (end != std::string::npos) {
           result.push_back(str.substr(start, end - start));
           start = end + delimiter.length();
           end = str.find(delimiter, start);
       }
       result.push_back(str.substr(start)); // 处理最后一个子字符串
       return result;
   }
   
   int main() {
       std::string str = "apple,banana,orange,grape";
       std::string delimiter = ",";
       std::vector tokens = splitString(str, delimiter);
       for (const auto& token : tokens) {
           std::cout << token << std::endl;
       }
       return 0;
   }

   这种方法的优点是简单易懂，缺点是效率相对较低，特别是当分隔符出现频率很高时。

2. 使用std::getline： std::getline可以从输入流中读取一行，并可以指定分隔符。 虽然它通常用于从文件中读取行，但也可以用于分割字符串。需要将字符串包装成std::stringstream。

   #include 
   #include 
   #include 
   #include 
   
   std::vector splitString(const std::string& str, char delimiter) {
       std::vector result;
       std::stringstream ss(str);
       std::string token;
       while (std::getline(ss, token, delimiter)) {
           result.push_back(token);
       }
       return result;
   }
   
   int main() {
       std::string str = "apple,banana,orange,grape";
       char delimiter = ',';
       std::vector tokens = splitString(str, delimiter);
       for (const auto& token : tokens) {
           std::cout << token << std::endl;
       }
       return 0;
   }

   std::getline的优点是代码简洁，效率也比find和substr略高。但它只能使用单个字符作为分隔符。

3. 使用Boost库的boost::split： Boost库提供了强大的字符串处理功能，包括boost::split函数，可以方便地进行字符串分割。

   #include 
   #include 
   #include 
   #include 
   
   int main() {
       std::string str = "apple,banana,orange,grape";
       std::vector tokens;
       boost::split(tokens, str, boost::is_any_of(","));
       for (const auto& token : tokens) {
           std::cout << token << std::endl;
       }
       return 0;
   }

   Boost库的boost::split功能强大，支持多种分隔符，包括正则表达式。 但需要引入Boost库，这可能会增加项目的依赖性。

4. 使用C风格的字符串函数strtok： strtok是C标准库中的函数，可以用于分割C风格的字符串。 注意： strtok是线程不安全的，并且会修改原始字符串。 不推荐在C++中使用，除非你明确知道自己在做什么。

   #include 
   #include 
   #include 
   #include 
   
   std::vector splitString(char* str, const char* delimiter) {
       std::vector result;
       char* token = strtok(str, delimiter);
       while (token != nullptr) {
           result.push_back(token);
           token = strtok(nullptr, delimiter);
       }
       return result;
   }
   
   int main() {
       std::string str = "apple,banana,orange,grape";
       char* cstr = new char[str.length() + 1];
       strcpy(cstr, str.c_str());
       std::vector tokens = splitString(cstr, ",");
       for (const auto& token : tokens) {
           std::cout << token << std::endl;
       }
       delete[] cstr; // 释放内存
       return 0;
   }

   使用strtok需要特别小心，因为它会修改原始字符串，并且是线程不安全的。 此外，还需要手动分配和释放内存。

C++字符串分割时如何处理空字符串？

在字符串分割时，可能会遇到连续的分隔符，导致出现空字符串。 处理空字符串的方式取决于具体需求。 可以选择忽略空字符串，也可以将其保留。

• 忽略空字符串： 在分割字符串时，可以添加一个判断，如果子字符串为空，则不将其添加到结果中。

  std::vector splitString(const std::string& str, const std::string& delimiter) {
      std::vector result;
      size_t start = 0;
      size_t end = str.find(delimiter);
      while (end != std::string::npos) {
          std::string token = str.substr(start, end - start);
          if (!token.empty()) { // 忽略空字符串
              result.push_back(token);
          }
          start = end + delimiter.length();
          end = str.find(delimiter, start);
      }
      std::string token = str.substr(start);
      if (!token.empty()) { // 忽略最后一个空字符串
          result.push_back(token);
      }
      return result;
  }

• 保留空字符串： 如果需要保留空字符串，则直接将子字符串添加到结果中即可。

如何根据多个分隔符分割C++字符串？

如果需要根据多个分隔符分割字符串，可以使用正则表达式或者Boost库的boost::split函数。

• 使用正则表达式： 可以使用std::regex和std::sregex_token_iterator来根据正则表达式分割字符串。

  #include 
  #include 
  #include 
  #include 
  
  std::vector splitString(const std::string& str, const std::string& delimiters) {
      std::vector result;
      std::regex re(delimiters);
      std::sregex_token_iterator it(str.begin(), str.end(), re, -1);
      std::sregex_token_iterator end;
      while (it != end) {
          result.push_back(it->str());
          ++it;
      }
      return result;
  }
  
  int main() {
      std::string str = "apple,banana;orange|grape";
      std::string delimiters = ",;|";
      std::vector tokens = splitString(str, delimiters);
      for (const auto& token : tokens) {
          std::cout << token << std::endl;
      }
      return 0;
  }

  使用正则表达式可以灵活地定义分隔符，但需要了解正则表达式的语法。

• 使用Boost库的boost::split： boost::split函数可以直接使用boost::is_any_of来指定多个分隔符。

  #include 
  #include 
  #include 
  #include 
  
  int main() {
      std::string str = "apple,banana;orange|grape";
      std::vector tokens;
      boost::split(tokens, str, boost::is_any_of(",;|"));
      for (const auto& token : tokens) {
          std::cout << token << std::endl;
      }
      return 0;
  }

  boost::split使用起来更加简洁，但同样需要引入Boost库。

如何优化C++字符串分割的性能？

字符串分割的性能优化主要集中在减少不必要的内存分配和拷贝操作。

1. 避免不必要的拷贝： 在分割字符串时，尽量使用引用或指针，避免拷贝子字符串。 例如，可以将结果存储在一个预先分配好的std::vector中，而不是每次都创建一个新的std::string。

2. 使用std::string_view： std::string_view是C++17引入的一个类，它提供了对字符串的非拥有视图。 使用std::string_view可以避免字符串的拷贝，提高性能。

   #include 
   #include 
   #include 
   #include 
   
   std::vector splitString(std::string_view str, std::string_view delimiter) {
       std::vector result;
       size_t start = 0;
       size_t end = str.find(delimiter);
       while (end != std::string::npos) {
           result.push_back(str.substr(start, end - start));
           start = end + delimiter.length();
           end = str.find(delimiter, start);
       }
       result.push_back(str.substr(start));
       return result;
   }
   
   int main() {
       std::string str = "apple,banana,orange,grape";
       std::string_view delimiter = ",";
       std::vector tokens = splitString(str, delimiter);
       for (const auto& token : tokens) {
           std::cout << token << std::endl;
       }
       return 0;
   }

   需要注意的是，std::string_view只是一个视图，它并不拥有字符串的所有权。 因此，在使用std::string_view时，需要确保原始字符串的生命周期长于std::string_view。

3. 使用预编译的正则表达式： 如果使用正则表达式进行分割，可以预先编译正则表达式，避免每次分割都重新编译。

   #include 
   #include 
   #include 
   #include 
   
   std::vector splitString(const std::string& str, const std::regex& re) {
       std::vector result;
       std::sregex_token_iterator it(str.begin(), str.end(), re, -1);
       std::sregex_token_iterator end;
       while (it != end) {
           result.push_back(it->str());
           ++it;
       }
       return result;
   }
   
   int main() {
       std::string str = "apple,banana;orange|grape";
       std::regex re("[,;|]"); // 预编译正则表达式
       std::vector tokens = splitString(str, re);
       for (const auto& token : tokens) {
           std::cout << token << std::endl;
       }
       return 0;
   }

   预编译正则表达式可以显著提高性能，特别是当需要多次分割字符串时。

选择合适的字符串分割方法，并进行适当的优化，可以有效地提高程序的性能。