In the realm of C++ programming, string manipulation is a fundamental aspect, and the ability to compare strings efficiently is often crucial. The C++ Standard Library provides a robust and versatile tool for this purpose: the std::string::compare function. This function is a member of the std::string class and offers a variety of ways to compare string objects, substrings, and even C-style character arrays. Understanding its different overloads and return values is key to writing effective and reliable C++ code. This article delves into the intricacies of std::string::compare, providing a comprehensive guide for developers seeking to master C++ string comparison.
The std::string::compare function allows you to compare a string object (or a part of it) with another string or character sequence. It offers flexibility through several overloaded versions, each designed to handle different comparison scenarios. Let’s explore these variations in detail.
Overload 1: Comparing Full Strings
int compare (const string& str) const noexcept;The simplest form of std::string::compare is used to compare the entire string object with another string object (str). This overload takes a single argument, which is a constant reference to the string you want to compare against.
Example:
#include <iostream>
#include <string>
int main() {
std::string str1 = "apple";
std::string str2 = "banana";
std::string str3 = "apple";
int result1 = str1.compare(str2); // Compare "apple" and "banana"
int result2 = str1.compare(str3); // Compare "apple" and "apple"
if (result1 != 0) {
std::cout << """ << str1 << "" is not equal to "" << str2 << """ << std::endl;
}
if (result2 == 0) {
std::cout << """ << str1 << "" is equal to "" << str3 << """ << std::endl;
}
return 0;
}This code snippet demonstrates a basic string comparison using the first overload. It compares “apple” with “banana” and then “apple” with “apple”, illustrating how compare can determine string equality and inequality.
Overload 2: Comparing Substrings
std::string::compare also provides overloads to compare specific substrings:
int compare (size_t pos, size_t len, const string& str) const;
int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen = npos) const;These overloads allow you to compare a substring of the original string with either a full string or a substring of another string.
pos: The starting position of the substring within the string object you are callingcompareon.len: The length of the substring to be compared.str: The string object to compare against.subpos: (For the second substring overload) The starting position of the substring within thestrobject.sublen: (For the second substring overload) The length of the substring within thestrobject.nposindicates comparing to the end of the string.
Example:
#include <iostream>
#include <string>
int main() {
std::string str1 = "comparing apples";
std::string str2 = "apples and oranges";
// Compare "apples" (substring of str1) with "apples and oranges"
int result1 = str1.compare(10, 6, str2);
if (result1 == 0) {
std::cout << "Substring of str1 equals str2 from the beginning" << std::endl;
}
// Compare "apples" (substring of str1) with "apples" (substring of str2)
int result2 = str1.compare(10, 6, str2, 0, 6);
if (result2 == 0) {
std::cout << "Substring of str1 equals substring of str2" << std::endl;
}
return 0;
}This example showcases how to compare substrings using different variations of the substring overload. It highlights the flexibility in specifying which parts of the strings to compare.
Overload 3: Comparing with C-style Strings
For compatibility with C-style strings (null-terminated character arrays), std::string::compare offers these overloads:
int compare (const char* s) const;
int compare (size_t pos, size_t len, const char* s) const;These versions allow you to compare a std::string object (or a substring) with a C-style string.
s: A pointer to a null-terminated character array.
Example:
#include <iostream>
#include <string>
int main() {
std::string str1 = "string and c-string";
const char* c_str = "c-string";
// Compare str1 with c-style string
int result1 = str1.compare(c_str);
if (result1 > 0) {
std::cout << "str1 is lexicographically greater than c_str" << std::endl;
}
// Compare substring of str1 with c-style string
int result2 = str1.compare(11, 8, c_str);
if (result2 == 0) {
std::cout << "Substring of str1 equals c_str" << std::endl;
}
return 0;
}This example demonstrates comparing a std::string object and its substring with a C-style string, bridging the gap between C++ string objects and traditional C-style strings.
Overload 4: Comparing with Character Buffers
The most explicit control over comparison with character arrays comes with this overload:
int compare (size_t pos, size_t len, const char* s, size_t n) const;This overload allows you to compare a substring of the std::string object with a specific number of characters from a character array.
n: The number of characters from the character arraysto use for comparison.
Example:
#include <iostream>
#include <string>
int main() {
std::string str1 = "buffer comparison example";
const char* buffer = "buffer test string";
// Compare substring of str1 with first 6 characters of buffer
int result = str1.compare(0, 6, buffer, 6);
if (result == 0) {
std::cout << "First 6 chars of str1 equal first 6 chars of buffer" << std::endl;
}
return 0;
}This example shows how to compare a substring with a specific portion of a character buffer, offering precise control over the number of characters involved in the comparison.
Return Value of std::string::compare
The std::string::compare function returns an integer value that indicates the relationship between the “compared string” (the string object or substring on which compare is called) and the “comparing string” (the argument passed to compare).
| Return Value | Relationship |
|---|---|
0 |
The “compared string” and the “comparing string” are equal. |
< 0 |
The “compared string” is lexicographically less than the “comparing string.” This can mean: |
| – The first differing character in the “compared string” has a lower value than in the “comparing string.” | |
| – All compared characters are equal, but the “compared string” is shorter. | |
> 0 |
The “compared string” is lexicographically greater than the “comparing string.” This can mean: |
| – The first differing character in the “compared string” has a higher value than in the “comparing string.” | |
| – All compared characters are equal, but the “compared string” is longer. |
Understanding these return values is crucial for using std::string::compare effectively in conditional statements and algorithms.
<cite>// comparing apples with apples</cite>
#include <iostream>
#include <string>
int main () {
std::string str1 ("green apple");
std::string str2 ("red apple");
if (str1.compare(str2) != 0)
std::cout << str1 << " is not " << str2 << 'n';
if (str1.compare(6,5,"apple") == 0)
std::cout << "still, " << str1 << " is an applen";
if (str2.compare(str2.size()-5,5,"apple") == 0)
std::cout << "and " << str2 << " is also an applen";
if (str1.compare(6,5,str2,4,5) == 0)
std::cout << "therefore, both are applesn";
return 0;
}Output:
green apple is not red apple
still, green apple is an apple
and red apple is also an apple
therefore, both are applesThis example elegantly demonstrates various use cases of std::string::compare, from comparing entire strings to substrings and even substrings of different strings. It clearly illustrates how the return value is used to determine the relationship between the compared strings.
Complexity and Exception Safety
The time complexity of std::string::compare is generally linear in the length of the strings being compared. This means the execution time grows proportionally to the number of characters being compared.
In terms of exception safety, the noexcept specification for the full string comparison overload indicates that it will not throw exceptions under normal circumstances. However, it’s important to note that using incorrect positions or lengths in substring comparisons can lead to std::out_of_range exceptions if the position is invalid. Additionally, when working with C-style strings or buffers, ensure that the pointers are valid and the lengths are within bounds to avoid undefined behavior.
Conclusion
std::string::compare is a powerful and versatile function for performing string comparisons in C++. Its multiple overloads cater to a wide range of comparison needs, from simple full string comparisons to complex substring and buffer comparisons. By understanding its different forms and return values, developers can effectively leverage this function to implement robust and efficient string manipulation logic in their C++ applications. Whether you are checking for string equality, ordering strings lexicographically, or comparing specific parts of strings, std::string::compare provides the tools you need for precise and reliable C++ string comparison operations.
