How to Compare Strings in C++: A Comprehensive Guide

Comparing strings is a fundamental operation in programming, and C++ offers several ways to achieve this. Whether you’re checking for equality, ordering strings lexicographically, or performing more complex comparisons, understanding the available methods is crucial for effective C++ programming. This guide will explore the different techniques for comparing strings in C++, providing clear explanations and practical examples to help you master this essential skill.

In C++, strings are objects of the std::string class, which provides built-in functionalities for string manipulation, including comparison. Let’s delve into the primary methods for comparing strings: relational operators and the compare() function.

Methods for Comparing Strings in C++

C++ provides two main approaches to compare strings:

1. Using Relational Operators

C++ allows you to use relational operators directly with std::string objects. These operators are intuitive and straightforward for simple comparisons. The relational operators available for string comparison are:

• == (Equal to): Checks if two strings are exactly the same.
• != (Not equal to): Checks if two strings are different.
• > (Greater than): Checks if the first string is lexicographically greater than the second.
• < (Less than): Checks if the first string is lexicographically less than the second.
• >= (Greater than or equal to): Checks if the first string is lexicographically greater than or equal to the second.
• <= (Less than or equal to): Checks if the first string is lexicographically less than or equal to the second.

Lexicographical comparison refers to the dictionary order. Strings are compared character by character from left to right. If the characters at a certain position are different, the string with the character of higher ASCII value is considered greater. If one string is a prefix of another (e.g., “Geek” and “Geeks”), the longer string is considered greater.

Let’s illustrate with a code example:

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";
    std::string str3 = "Hello";

    // Equality and Inequality
    if (str1 == str3) {
        std::cout << str1 << " is equal to " << str3 << std::endl;
    } else {
        std::cout << str1 << " is not equal to " << str3 << std::endl;
    }

    if (str1 != str2) {
        std::cout << str1 << " is not equal to " << str2 << std::endl;
    }

    // Lexicographical Comparison
    if (str1 > str2) {
        std::cout << str1 << " is greater than " << str2 << std::endl;
    } else {
        std::cout << str2 << " is greater than " << str1 << std::endl;
    }

    if (str1 < str2) {
         std::cout << str1 << " is less than " << str2 << std::endl;
    }


    return 0;
}

Output:

Hello is equal to Hello
Hello is not equal to World
World is greater than Hello
Hello is less than World

Time Complexity: O(min(n, m)), where n and m are the lengths of the strings being compared. This is because the comparison stops at the first differing character or when the end of the shorter string is reached.

Auxiliary Space: O(1), as the comparison is done in place without requiring significant extra space.

2. Using the std::string::compare() Function

The std::string class provides a member function called compare() which offers more flexibility and detailed comparison options. The compare() function returns an integer value that indicates the relationship between two strings:

• Returns 0: If the strings are equal.
• Returns a negative value: If the first string is lexicographically less than the second string.
• Returns a positive value: If the first string is lexicographically greater than the second string.

Here’s how to use the compare() function:

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Geeks";
    std::string str2 = "forGeeks";
    std::string str3 = "Geeks";

    // Comparing using compare()
    int result1 = str1.compare(str2);
    if (result1 == 0) {
        std::cout << str1 << " is equal to " << str2 << std::endl;
    } else if (result1 < 0) {
        std::cout << str1 << " is less than " << str2 << std::endl;
    } else {
        std::cout << str1 << " is greater than " << str2 << std::endl;
    }

    int result2 = str1.compare(str3);
    if (result2 == 0) {
        std::cout << str1 << " is equal to " << str3 << std::endl;
    } else {
        std::cout << str1 << " is not equal to " << str3 << std::endl;
    }

    return 0;
}

Output:

Geeks is less than forGeeks
Geeks is equal to Geeks

Time Complexity: O(min(n, m)), similar to relational operators.

Auxiliary Space: O(1).

compare() for Substring Comparison

One of the advantages of compare() is its ability to compare substrings. You can specify starting positions and lengths for both strings in the comparison. The compare() function has several overloaded versions. For substring comparison, you can use a version like this:

str1.compare(pos1, len1, str2, pos2, len2)

• pos1: Starting position in str1.
• len1: Length of substring in str1.
• str2: The second string to compare with.
• pos2: Starting position in str2.
• len2: Length of substring in str2.

Here’s an example of substring comparison:

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Programming";
    std::string str2 = "Coding";

    // Compare "gram" from str1 (starting at index 2, length 4)
    // with "odin" from str2 (starting at index 1, length 4)
    int result = str1.compare(2, 4, str2, 1, 4);

    if (result == 0) {
        std::cout << "Substrings are equal" << std::endl;
    } else {
        std::cout << "Substrings are not equal" << std::endl;
    }

    return 0;
}

Output:

Substrings are not equal

In this example, “gram” from “Programming” is compared with “odin” from “Coding”. Since they are not the same, the output indicates that the substrings are not equal.

Relational Operators vs. compare(): Key Differences

While both relational operators and the compare() function can be used for string comparison, there are some key distinctions:

1. Return Type: Relational operators return a boolean value (true or false), making them suitable for direct conditional checks in if statements or loops. compare() returns an integer, providing more information about the comparison result (less than, equal to, or greater than).

2. Flexibility: The compare() function offers more flexibility, especially with its ability to compare substrings. Relational operators are primarily designed for comparing entire strings. If you need to compare specific parts of strings, compare() is the more powerful and convenient choice.

3. Readability for Simple Cases: For straightforward equality or inequality checks, relational operators often lead to more concise and readable code. str1 == str2 is arguably more immediately understandable than checking str1.compare(str2) == 0.

Best Practices for String Comparison in C++

• Choose the Right Method: For simple equality checks or lexicographical ordering of entire strings, relational operators are often sufficient and more readable. When you need to compare substrings or require more detailed comparison information (less than, equal to, greater than), use the compare() function.

• Understand Lexicographical Order: Be aware that string comparison in C++ is lexicographical (dictionary order) and case-sensitive by default. “Apple” is considered less than “apple”.

• Performance Considerations: For most common string comparison tasks, the performance difference between relational operators and compare() is negligible. Both have a time complexity of O(min(n, m)). Choose the method that best suits your needs in terms of readability and functionality.

Conclusion

Comparing strings in C++ is a common and essential task. C++ provides both relational operators and the std::string::compare() function to perform these comparisons. Relational operators offer simplicity and readability for basic comparisons, while compare() provides greater flexibility, especially for substring comparisons and obtaining detailed comparison results. By understanding these methods and their differences, you can effectively compare strings in your C++ programs and choose the most appropriate technique for each situation.