C++: Strings Helper Utils

In this post I share some of the C++ string utilities that I have gathered over the time.

Split string by last delimiter #

std::vector<std::string> splitLast(const std::string_view& str, const std::string_view& delim) {
    const auto pos = str.find_last_of(delim);
    if (pos != std::string::npos) {
        return {
            std::string{str.substr(0, pos)},
            std::string{str.substr(pos + 1)},
        };
    }

    return {std::string{str}};
}

Split string to multiple tokens #

std::vector<std::string> split(const std::string_view& str, const std::string_view& delim) {
    std::vector<std::string> strings;
    size_t pos = 0;
    size_t next = 0;
    while ((next = str.find(delim, pos)) != std::string::npos) {
        strings.emplace_back(str.substr(pos, next - pos));
        pos = next + delim.size();
    }

    if (pos < str.size()) {
        strings.emplace_back(str.substr(pos));
    }

    return strings;
}

Check if string starts with a string #

bool endsWith(const std::string_view& str, const std::string_view& ending) {
    if (str.length() >= ending.length()) {
        return (0 == str.compare(str.length() - ending.length(), ending.length(), ending));
    } else {
        return false;
    }
}

Check if string ends with a string #

bool startsWith(const std::string_view& str, const std::string_view& start) {
    if (str.length() >= start.length()) {
        return (0 == str.compare(0, start.length(), start));
    } else {
        return false;
    }
}

Strip whitespace from the beginning and the end #

std::string strip(std::string_view str) {
    while (!str.empty() && (str.front() == ' ' || str.front() == '\n')) {
        str = str.substr(1);
    }
    while (!str.empty() && (str.back() == ' ' || str.back() == '\n')) {
        str = str.substr(0, str.size() - 1);
    }
    return std::string{str};
}

Repeat string N times #

std::string repeat(const std::string_view& str, const size_t num) {
    std::stringstream ss;
    for (size_t i = 0; i < num; i++) {
        ss << str;
    }
    return ss.str();
}

Replace all occurrences of string in a string #

std::string replace(const std::string_view& str, const std::string_view& from, const std::string_view& to) {
    if (from.empty()) {
        return "";
    }

    std::string result{str};

    size_t start = 0;
    while ((start = result.find(from, start)) != std::string::npos) {
        result.replace(start, from.length(), to);
        start += to.length();
    }

    return result;
}

Convert camel case to snake case string #

This is not the fastest but it does it job well enough.

std::string camelCaseToSnakeCase(const std::string_view& str) {
    std::string res;
    for (char c : str) {
        if (std::isupper(c)) {
            if (!res.empty()) {
                res += '_';
            }
            res += static_cast<char>(std::tolower(c));
        } else {
            res += c;
        }
    }
    return res;
}

Convert bytes to a hex string #

std::string toHexString(const void* src, const size_t size) {
    static const std::string_view chars = "0123456789abcdef";

    std::string res;
    res.resize(size * 2);

    const auto* ptr = reinterpret_cast<const char*>(src);
    for (size_t i = 0; i < size; i++) {
        res[i * 2 + 0] = chars[(ptr[i] & 0xF0) >> 4];
        res[i * 2 + 1] = chars[(ptr[i] & 0x0F) >> 0];
    }

    return res;
}

Convert string to lower case #

Note, this does not respect localization. It is very stupid simple. Don’t use it for any other languages other than English.

std::string toLower(const std::string_view& str) {
    std::string res{str};
    std::transform(res.begin(), res.end(), res.begin(), [](char c) { return std::tolower(c); });
    return res;
}