Case-Insensitive String Comparison in C++

When developing applications that involve user input or data from various sources, you often need to compare strings without regard to case (i.e., treat "Hello" and "hello" as equal). This tutorial explores several techniques for achieving case-insensitive string comparisons in C++, ranging from simple character-by-character comparisons to leveraging more robust Unicode-aware libraries.

The Challenge

Directly comparing strings using == or != is case-sensitive. To perform a case-insensitive comparison, you need to either transform both strings to a consistent case (e.g., all lowercase or all uppercase) before comparing, or implement a comparison function that ignores case differences. The former approach modifies the original strings, which might not always be desirable. The latter is generally preferable.

Simple Character-by-Character Comparison

A straightforward approach is to iterate through the strings, comparing characters after converting them to a common case. Here’s an implementation using std::tolower:

#include <cctype> // std::tolower
#include <string>
#include <algorithm>

bool iequals(const std::string& a, const std::string& b) {
    if (a.size() != b.size()) {
        return false;
    }

    for (size_t i = 0; i < a.size(); ++i) {
        if (std::tolower(static_cast<unsigned char>(a[i])) != std::tolower(static_cast<unsigned char>(b[i]))) {
            return false;
        }
    }

    return true;
}

// Using std::equal for a more concise version (C++11 and later)
bool iequals_stl(const std::string& a, const std::string& b) {
    if (a.size() != b.size()) return false;
    return std::equal(a.begin(), a.end(), b.begin(), [](char c1, char c2){
        return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2));
    });
}

Explanation:

The iequals function first checks if the strings have the same length. If not, they can’t be equal.
It then iterates through the strings, character by character.
std::tolower converts each character to its lowercase equivalent. The static_cast<unsigned char> is essential to avoid undefined behavior when dealing with characters outside the ASCII range (e.g., accented characters). std::tolower is defined to operate on int values representing unsigned char or EOF.
If the lowercase versions of the characters don’t match, the function immediately returns false.
If the loop completes without finding any mismatches, the function returns true.
The iequals_stl function uses std::equal and a lambda expression to achieve the same result in a more concise way.

Limitations:

This approach works well for ASCII strings but may not handle Unicode characters correctly. Unicode characters can have more complex case mappings, and std::tolower might not produce the expected results for all Unicode characters.

Using `std::string_view` (C++17 and later)

std::string_view provides a non-owning view into a string, which can be more efficient than passing std::string objects by value. This is especially useful if you are performing many comparisons.

#include <cctype>
#include <string_view>
#include <algorithm>

bool iequals_sv(std::string_view a, std::string_view b) {
    if (a.size() != b.size()) {
        return false;
    }
    return std::equal(a.begin(), a.end(), b.begin(), [](char c1, char c2){
        return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2));
    });
}

Leveraging `char_traits` for Custom Comparison

You can customize the comparison behavior by defining your own char_traits specialization. This allows you to define how characters are compared, copied, and other operations are performed.

#include <string>
#include <cctype>

struct ci_char_traits : public std::char_traits<char> {
    static bool eq(char c1, char c2) { return std::tolower(c1) == std::tolower(c2); }
    static bool ne(char c1, char c2) { return std::toupper(c1) != std::toupper(c2); }
    static bool lt(char c1, char c2) { return std::tolower(c1) < std::tolower(c2); }
    static int compare(const char* s1, const char* s2, size_t n) {
        while(n--) {
            if(std::tolower(*s1) < std::tolower(*s2)) return -1;
            if(std::tolower(*s1) > std::tolower(*s2)) return 1;
            ++s1; ++s2;
        }
        return 0;
    }
};

typedef std::basic_string<char, ci_char_traits> ci_string;

int main() {
    ci_string str1 = "Hello";
    ci_string str2 = "hello";
    if (str1 == str2) {
        // Strings are equal (case-insensitive)
    }
}

Explanation:

We create a struct ci_char_traits that inherits from std::char_traits<char>.
We override the eq, ne, lt, and compare methods to provide case-insensitive comparison logic.
We then define a ci_string type using std::basic_string and our custom ci_char_traits.

Unicode Considerations and ICU

For robust Unicode handling, consider using a dedicated Unicode library like IBM ICU (International Components for Unicode). ICU provides comprehensive support for Unicode normalization, case mapping, and collation. Using ICU is essential when dealing with strings from diverse languages and scripts. ICU handles complex case mappings and ensures correct comparison results for all Unicode characters.

Choosing the Right Approach

For simple ASCII strings, the character-by-character comparison with std::tolower is often sufficient.
If you need to compare strings frequently, using std::string_view can improve performance.
For more advanced Unicode support, ICU is the recommended solution.
Customizing char_traits offers flexibility but can be more complex to implement and maintain.