How to Split a String by a String Delimiter in C++

By the end of this page, you will understand why std::getline cannot split on multi-character delimiters, and how to use std::string::find and std::string::substr to split strings using string delimiters like ">=" in C++. You will also see common patterns, mistakes, and a small practical project.

In C++, std::getline supports only a single character delimiter. That works for cases like splitting by a space, comma, or colon, but not for delimiters made of multiple characters such as ">=", "--", or "||".

When your delimiter is a string, the usual approach in standard C++ is:

1. Search for the delimiter inside the string using std::string::find
2. Extract the part before it using std::string::substr
3. Extract the part after it using std::string::substr again

This matters because real programs often parse structured text that uses multi-character separators, such as:

• configuration entries like key=>value
• log data like time||message
• simple query expressions like name>=john
• custom file formats and protocols

Understanding this pattern is useful because find + substr is one of the most common standard-library techniques for string parsing in C++. It is simple, readable, and does not require non-standard libraries.

Think of a string as a long strip of paper.

• find helps you locate where a marker appears on the strip
• substr lets you cut out pieces of the strip

If the string is:

scott>=tiger

and your marker is:

>=

then you:

1. find where ">=" starts
2. cut everything before it → scott
3. cut everything after it → tiger

So instead of saying “split by one character,” you are really saying “find this substring, then slice around it.”

Core idea

Use:

• find(delimiter) to locate the delimiter
• substr(start, length) to extract pieces

Example: split once by a string delimiter

#include <iostream>
#include <string>

int main()
{
    std::string input = "scott>=tiger";
    std::string delimiter = ">=";

    std::size_t pos = input.find(delimiter);

    if (pos != std::string::npos)
    {
        std::string left = input.substr(0, pos);
        std::string right = input.substr(pos + delimiter.length());

        std::cout << "Left: " << left << '\n';
        std::cout << "Right: " << right << '\n';
    }
    else
    {
        std::cout << "Delimiter not found\n";
    }
}

Output

Left: scott
Right: tiger

Why this works

Consider this code:

#include <iostream>
#include <string>

int main()
{
    std::string input = "scott>=tiger";
    std::string delimiter = ">=";

    std::size_t pos = input.find(delimiter);

    if (pos != std::string::npos)
    {
        std::string left = input.substr(0, pos);
        std::string right = input.substr(pos + delimiter.size());

        std::cout << left << '\n';
        std::cout << right << '\n';
    }
}

Step-by-step

1. Store the input

std::string input = "scott>=tiger";

The string contains 12 characters:

s c o t t > = t i g e r
0 1 2 3 4 5 6 7 8 9 10 11

2. Store the delimiter

std::string delimiter = ">=";

Its length is 2.

3. Find the delimiter position

Multi-character delimiters appear more often than beginners expect.

Common uses

• Parsing configuration lines
  • Example: host=>localhost
• Processing simple expressions
  • Example: age>=18
• Reading custom file formats
  • Example: header||body
• Handling logs or exported data
  • Example: timestamp-->message
• Tokenizing user input in small tools
  • Example: username::role

Practical example: parsing a filter rule

std::string rule = "price>=100";
std::string delimiter = ">=";
std::size_t pos = rule.find(delimiter);

if (pos != std::string::npos)
{
    std::string field = rule.substr(0, pos);
    std::string value = rule.substr(pos + delimiter.size());
}

This could be used in a search tool, reporting script, or command parser.

In real codebases, developers usually wrap this logic in a reusable function instead of writing find and substr repeatedly.

Common pattern: return two parts

#include <string>
#include <utility>

std::pair<std::string, std::string> split_once(const std::string& input, const std::string& delimiter)
{
    std::size_t pos = input.find(delimiter);

    if (pos == std::string::npos)
    {
        return {input, ""};
    }

    return {
        input.substr(0, pos),
        input.substr(pos + delimiter.size())
    };
}

Guard clause pattern

A guard clause checks bad or special cases early:

if (delimiter.empty())
{
    // handle invalid delimiter
}

This is important because splitting by an empty delimiter is usually not meaningful.

Validation pattern

Developers often validate input before parsing:

1. Trying to use std::getline with a string delimiter

This does not work because the third parameter must be a single char.

std::getline(stream, parsed, ">="); // wrong

Use find and substr instead.

2. Forgetting to check whether the delimiter exists

Broken code:

std::size_t pos = input.find(delimiter);
std::string left = input.substr(0, pos);
std::string right = input.substr(pos + delimiter.size());

If the delimiter is not found, pos is std::string::npos, which can lead to incorrect behavior.

Better:

std::size_t pos = input.find(delimiter);
if (pos != std::string::npos)
{
    std::string left = input.substr(0, pos);
    std::string right = input.(pos + delimiter.());
}

Single-character vs string delimiter parsing

find vs stringstream

Quick reference

Split once by string delimiter

std::string input = "scott>=tiger";
std::string delimiter = ">=";

std::size_t pos = input.find(delimiter);
if (pos != std::string::npos)
{
    std::string left = input.substr(0, pos);
    std::string right = input.substr(pos + delimiter.size());
}

Important methods

• find(str) → returns index of first match or std::string::npos
• substr(start, length) → returns part of a string
• substr(start) → returns from start to end
• size() or length() → number of characters

Rules

• std::getline only accepts a char delimiter
• Use find for multi-character delimiters
• Always check pos != std::string::npos

Can std::getline use a string delimiter in C++?

No. The delimiter parameter for std::getline is a single char, not a std::string.

What is the standard C++ way to split by ">="?

Use std::string::find to locate the delimiter and std::string::substr to extract the parts before and after it.

What happens if the delimiter is not found?

find returns std::string::npos. You should check for that before calling substr based on the found position.

How do I split a string multiple times using the same delimiter?

Use a loop with find, extract the token, remove or skip the processed part, and continue until no delimiter remains.

Is find better than regular expressions for this task?

For a fixed delimiter like ">=", yes. It is simpler, easier to read, and usually more efficient.

Can I split by more than one possible delimiter?

Yes, but you need extra logic, such as checking several delimiters or using a more advanced parser.

• std::string::find — used to locate a substring inside a string.
• std::string::substr — used to extract parts of a string after finding positions.
• std::getline — useful for single-character delimiters and stream-based parsing.
• std::stringstream — commonly used for tokenizing formatted text from strings.
• string indexing — helps you understand positions and substring boundaries.
• input validation — important for checking missing delimiters and malformed input.
• loops — useful when you need to split by a delimiter multiple times.
• regular expressions — an alternative for more complex text parsing patterns.