C++ split string: 3 ways with code (getline, find, views)

To split a string in C++, write a short loop: std::string has no split member. The shortest puts the text in a std::istringstream and calls std::getline(in, piece, ',') until the text runs out, adding each piece to a vector. For a delimiter of several characters, loop with find and substr; since C++20, std::views::split cuts the pieces for you.

#include <iostream>
#include <sstream>
#include <string>
#include <vector>

int main() {
    std::istringstream in("red,green,blue");
    std::vector<std::string> pieces;
    std::string piece;
    while (std::getline(in, piece, ',')) {
        pieces.push_back(piece);
    }

    std::cout << pieces.size() << " pieces\n";
    for (const std::string& p : pieces) {
        std::cout << p << '\n';
    }
}

It printed:

3 pieces
red
green
blue

The samples are C++17, except the std::views::split ones (C++20, and C++23 for std::ranges::to), built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++); all four printed the same for every sample. Since When lists compiler support for each standard’s features.

Does C++ have a split function?

Not as a member of std::string, in any standard up to C++26. You build the split from library pieces, and the delimiter decides which:

How do you split a string on a character with getline?

std::getline(in, piece, ',') reads characters up to the next comma, stores them in piece and throws the comma away; the loop ends when nothing is left to read. In the program above, std::istringstream, from <sstream>, is a stream that reads from a string in memory. std::getline is the same function that reads a whole line from std::cin; here it reads from the text, and its third argument is the delimiter, one char.

The last piece, blue, has no comma after it: getline reads it up to the end of the text and still returns it. The next call reads nothing at all, so it fails, and the loop stops.

How do you split on a string delimiter with find and substr?

Write a split() function: find the delimiter from the current position, cut the piece before it, jump past it and repeat; what is left after the last delimiter is the last piece. It works for ", ", "::" or any other delimiter:

std::vector<std::string> split(const std::string& text,
                               const std::string& delimiter) {
    if (delimiter.empty()) {
        return {text};  // nothing to cut on: the whole text
    }
    std::vector<std::string> pieces;
    std::string::size_type start = 0;
    std::string::size_type end = text.find(delimiter);
    while (end != std::string::npos) {
        pieces.push_back(text.substr(start, end - start));
        start = end + delimiter.size();  // jump past the delimiter
        end = text.find(delimiter, start);
    }
    pieces.push_back(text.substr(start));  // the rest is the last piece
    return pieces;
}
// ...
print(split("red, green, blue", ", "));
print(split("a::b::c", "::"));
print(split("red, green, blue", ""));

print writes the count and each piece in brackets. It printed:

3: [red][green][blue]
3: [a][b][c]
1: [red, green, blue]

find returns the index where the next delimiter starts, or std::string::npos when none is left, which ends the loop. substr(start, end - start) copies the piece before it: its second argument is a length, not an end index. The early return gives an empty delimiter the whole text as one piece, the third line.

How do you split a string on whitespace?

Read with >> instead of getline: in >> word skips any run of spaces, tabs and newlines, then reads up to the next one, so while (in >> word) gives no empty pieces.

std::istringstream in("  the quick   brown fox ");
std::vector<std::string> words;
std::string word;
while (in >> word) {  // skips every run of whitespace first
    words.push_back(word);
}

All four found the four words, [the][quick][brown][fox], and a text mixing tabs and newlines split into its words the same way. std::getline(in, piece, ' ') is the wrong tool here: on the same text it gave 8 pieces, four of them empty.

How do you split a string with std::views::split (C++20)?

Since C++20, text | std::views::split(',') hands you the pieces one at a time. Each piece is a view of the characters inside the original text, a subrange ([range.split]), not a new string, so you make a string only when you need one:

std::string text = "red,green,blue";
for (auto piece : text | std::views::split(',')) {  // C++20
    std::string s(piece.begin(), piece.end());  // piece -> string
    std::cout << '[' << s << ']';
}

It printed [red][green][blue], and std::views::split(", "sv) cut "red, green, blue" the same way, because std::views::split takes one character or a run of them as its delimiter. It needs <ranges>, C++20 (-std=c++20, /std:c++20) and GCC 12, or Clang 16 with libc++, or later: GCC 10 and 11 ship an earlier split_view whose pieces std::string(piece.begin(), piece.end()) cannot take. Built as C++17, all four rejected it.

Since C++23, std::ranges::to collects the pieces into a vector in one statement:

auto pieces = text | std::views::split(',')
            | std::ranges::to<std::vector<std::string>>();  // C++23

All four built it as C++23, printed the three pieces and rejected it as C++20. Name the whole element type: std::ranges::to<std::vector>() would deduce a vector of subranges, not of strings.

What happens with empty fields and a trailing delimiter?

The ways disagree at the end of the text. All three keep the empty field between two commas, but after a trailing comma the getline loop stops, while split() and views::split add one more, empty piece. For "a,,b," all four printed:

getline drops that last piece because the call after the trailing comma reads nothing and fails. An empty text differs too: the getline loop and views::split gave no pieces, but split() returned one empty piece, so check for it if an empty input should mean an empty list.

What about strtok and boost::split?

Avoid std::strtok: it changes the text it splits and skips empty fields.

char buffer[] = "a,,b,";
for (char* token = std::strtok(buffer, ","); token != nullptr;
     token = std::strtok(nullptr, ",")) {
    std::cout << '[' << token << "]\n";
}
std::cout << "buffer now reads: " << buffer << '\n';

It printed:

[a]
[b]
buffer now reads: a

It wrote a zero byte over each comma it cut at, which is why the array now reads just a. It also remembers its place between calls, so two splits cannot interleave, and the standard does not require it to be safe to call from two threads at once; on Windows, MSVC (C4996) and Clang warn that it may be unsafe.

In a project that already uses Boost, boost::split(result, input, is_any_of(","), token_compress_on) (declared as boost::algorithm::split, from <boost/algorithm/string.hpp>) fills a container in one call; token_compress_on merges adjacent separators (Boost’s usage notes).

Which way should you use?

More answers on strings and the rest of the library are in the Standard library section.