Splitting a String into a Vector

Splitting a string into substrings is a common task in text processing. While C++ doesn't have a built-in split() function like some other languages, we can implement one using the standard library.

Here's an efficient way to split a std::string into a std::vector of substrings based on a delimiter:

1#include <iostream>
2#include <string>
3#include <vector>
4#include <sstream>
5
6std::vector<std::string> split(
7  const std::string& s, char delimiter) {
8  std::vector<std::string> tokens;
9  std::string token;
10  std::istringstream tokenStream(s);
11  while (std::getline(
12    tokenStream, token, delimiter
13  )) {
14    if (!token.empty()) {
15      tokens.push_back(token);
16    }
17  }
18  return tokens;
19}
20
21int main() {
22  std::string text{"Hello,World,C++,Programming"};
23  char delimiter{','};
24
25  std::vector<std::string> result{
26      split(text, delimiter)};  
27
28  std::cout << "Original string: " << text << '\n';
29  std::cout << "Substrings:\n";
30  for (const auto& str : result) {
31    std::cout << "  " << str << '\n';
32  }
33}

1Original string: Hello,World,C++,Programming
2Substrings:
3  Hello
4  World
5  C++
6  Programming

Let's break down the split() function:

1. We create a std::vector<std::string> to store our substrings.
2. We use a std::istringstream to treat our input string as a stream of characters.
3. We use std::getline() with our chosen delimiter to extract substrings.
4. We check if the extracted substring is not empty before adding it to our vector.

This method is efficient because it avoids manual string manipulation and uses the stream extraction capabilities of C++. It handles empty substrings (like between consecutive delimiters) gracefully by ignoring them.

For more complex splitting needs, you might consider using regular expressions (<regex> header). However, for simple delimiter-based splitting, this method is usually more than sufficient and often more performant.

Remember, if you're working with very large strings or need to split strings frequently, you might want to consider passing the vector by reference to avoid copying:

1void split(
2  const std::string& s,
3  char delimiter,
4  std::vector<std::string>& tokens
5) {
6  // Same implementation as before,
7  // but using tokens directly
8}

This can be more efficient as it avoids creating and copying the vector when returning from the function.