Compare Strings in C: A Comprehensive Guide to `strcmp()`

In the realm of C programming, strings are fundamental data types used to represent text. A common task when working with strings is to compare them. C provides a built-in function, strcmp(), within its string library (string.h) to perform lexicographical comparison of two strings. This article delves into the intricacies of strcmp(), explaining its syntax, functionality, and providing practical examples to illustrate its usage. Whether you are a novice programmer or seeking to deepen your understanding, this guide will equip you with the knowledge to effectively compare strings in C.

Understanding the Syntax of strcmp()

The strcmp() function is defined in the string.h header file. To use it in your C programs, you must include this header file using the preprocessor directive #include <string.h>.

The syntax of the strcmp() function is as follows:

strcmp(s1, s2);

Parameters:

• s1: A pointer to the first string (character array).
• s2: A pointer to the second string (character array).

Return Value:

The strcmp() function returns an integer value based on the lexicographical comparison of the two strings:

• 0 (Zero): Returned if s1 and s2 are identical strings. This means they have the same sequence of characters.
• Greater than 0 (Positive): Returned if s1 is lexicographically greater than s2. This indicates that s1 would come after s2 in dictionary order.
• Less than 0 (Negative): Returned if s1 is lexicographically less than s2. This indicates that s1 would come before s2 in dictionary order.

How strcmp() Function Works: Lexicographical Comparison Explained

The strcmp() function operates by comparing the two input strings, s1 and s2, character by character. This comparison is lexicographical, meaning it follows the order of characters based on their ASCII values. Here’s a step-by-step breakdown of how strcmp() works:

1. Character-by-Character Comparison: strcmp() starts by comparing the first character of s1 with the first character of s2.

2. ASCII Value Comparison: The comparison is based on the ASCII values of the characters. For instance, ‘A’ has an ASCII value of 65, ‘a’ has 97, ‘0’ has 48, and so on.

3. Continuing the Comparison: If the characters at the current position are the same, strcmp() proceeds to compare the next characters in both strings. This process continues until one of the following conditions is met:

   • Mismatch Found: Characters at the current position in s1 and s2 are different.
   • Null Terminator Reached: The null terminator () is encountered in both strings simultaneously. The null terminator marks the end of a C-style string.

4. Determining the Return Value:

   • Strings are Identical: If strcmp() reaches the null terminator in both strings without finding any mismatched characters, it means the strings are identical. In this case, it returns 0.

   • Mismatch and Lexicographical Order: If a mismatch is found at a certain position:

     • If the ASCII value of the character in s1 is greater than the character in s2, strcmp() returns a positive value (greater than 0).
     • If the ASCII value of the character in s1 is less than the character in s2, strcmp() returns a negative value (less than 0).

   • One String is a Prefix of Another: If one string is a prefix of the other (e.g., “apple” and “apples”), the shorter string is considered lexicographically smaller. strcmp() will return a negative value if s1 is the prefix and a positive value if s2 is the prefix.

Example of strcmp() comparing identical strings.

Example of strcmp() where the first string is lexicographically larger.

Example of strcmp() where the first string is lexicographically smaller.

Practical Examples of strcmp() in C

Let’s explore several examples to solidify your understanding of strcmp() and its behavior in different scenarios.

Example 1: Comparing Identical Strings

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "Hello";
    char str2[] = "Hello";
    int result = strcmp(str1, str2);

    if (result == 0) {
        printf("Strings are equaln");
    } else {
        printf("Strings are not equaln");
    }
    return 0;
}

Output:

Strings are equal

Explanation: In this example, str1 and str2 both contain the string “Hello”. strcmp() correctly identifies them as identical and returns 0, leading to the output “Strings are equal”.

Example 2: Comparing Lexicographically Greater String

#include <stdio.h>
#include <string.h>

int main() {
    char string1[] = "zebra";
    char string2[] = "apple";
    int result = strcmp(string1, string2);

    if (result == 0) {
        printf("Strings are equaln");
    } else if (result > 0) {
        printf(""%s" is lexicographically greater than "%s"n", string1, string2);
    } else {
        printf(""%s" is lexicographically less than "%s"n", string1, string2);
    }
    return 0;
}

Output:

"zebra" is lexicographically greater than "apple"

Explanation: Here, “zebra” comes after “apple” in dictionary order. The comparison starts with ‘z’ and ‘a’. Since ‘z’ has a higher ASCII value than ‘a’, strcmp() immediately determines that “zebra” is lexicographically greater and returns a positive value.

Example 3: Comparing Lexicographically Smaller String

#include <stdio.h>
#include <string.h>

int main() {
    char s1[] = "Cat";
    char s2[] = "Dog";
    int result = strcmp(s1, s2);

    if (result == 0) {
        printf("Strings are equaln");
    } else if (result > 0) {
        printf(""%s" is lexicographically greater than "%s"n", s1, s2);
    } else {
        printf(""%s" is lexicographically less than "%s"n", s1, s2);
    }
    return 0;
}

Output:

"Cat" is lexicographically less than "Dog"

Explanation: “Cat” comes before “Dog” alphabetically. The comparison begins with ‘C’ and ‘D’. ‘C’ has a lower ASCII value than ‘D’, so strcmp() returns a negative value, indicating that “Cat” is lexicographically smaller.

Example 4: Case Sensitivity of strcmp()

strcmp() is case-sensitive. This means it distinguishes between uppercase and lowercase letters.

#include <stdio.h>
#include <string.h>

int main() {
    char caseStr1[] = "Hello";
    char caseStr2[] = "hello";
    int result = strcmp(caseStr1, caseStr2);

    if (result == 0) {
        printf("Strings are equaln");
    } else {
        printf("Strings are not equaln");
    }
    return 0;
}

Output:

Strings are not equal

Explanation: Even though the words are the same, “Hello” and “hello” are treated as different by strcmp() because ‘H’ and ‘h’ have different ASCII values. If you need a case-insensitive comparison, consider using strcasecmp() (non-standard, but available in many systems) or converting both strings to the same case before comparison.

Example 5: Sorting an Array of Strings using strcmp() and qsort()

strcmp() is frequently used as a comparison function when sorting arrays of strings. Combined with the qsort() function (from stdlib.h), you can efficiently sort strings lexicographically.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int compareStrings(const void *a, const void *b) {
    return strcmp(*(const char **)a, *(const char **)b);
}

int main() {
    const char *names[] = {"Charlie", "Alice", "Bob", "David"};
    int n = sizeof(names) / sizeof(names[0]);

    qsort(names, n, sizeof(names[0]), compareStrings);

    printf("Sorted names:n");
    for (int i = 0; i < n; i++) {
        printf("%sn", names[i]);
    }
    return 0;
}

Output:

Sorted names:
Alice
Bob
Charlie
David

Explanation:

1. compareStrings function: This function is designed to be used with qsort(). It takes two pointers to const void *, which qsort() uses to pass elements from the array. Inside the function, we cast these void pointers to const char ** (pointer to a pointer to char) to access the actual string pointers. Then, strcmp() is used to compare the two strings.

2. qsort() function: qsort() is a generic sorting function. We provide:

   • names: The array to be sorted.
   • n: The number of elements in the array.
   • sizeof(names[0]): The size of each element (which is the size of a char * pointer).
   • compareStrings: The comparison function we defined.

qsort() uses compareStrings to determine the order of elements, effectively sorting the names array lexicographically.

Common Pitfalls and Best Practices when Using strcmp()

• Null Pointer Checks: Always ensure that the pointers s1 and s2 passed to strcmp() are valid and not NULL. Passing NULL pointers can lead to segmentation faults or undefined behavior.

• Buffer Overflows (Less Relevant for strcmp() itself): While strcmp() itself doesn’t directly cause buffer overflows, be mindful of buffer sizes when manipulating strings before or after comparison. If you are copying strings based on comparison results, ensure destination buffers are large enough.

• Case Sensitivity: Remember that strcmp() is case-sensitive. If case-insensitive comparison is needed, use alternative methods like converting strings to lowercase/uppercase before comparison or using case-insensitive comparison functions if available in your environment.

• Return Value Interpretation: Carefully interpret the return value of strcmp() (0, positive, negative) to implement your logic correctly. Sometimes, beginners may mistakenly check only for equality (result == 0) and forget to handle the cases where strings are lexicographically ordered differently.

Frequently Asked Questions (FAQs) about strcmp()

1. When does strcmp() return 0?

strcmp() returns 0 when the two strings being compared are exactly identical, character for character.

2. What does a positive return value from strcmp() signify?

A positive return value indicates that the first string (s1) is lexicographically greater than the second string (s2).

3. What does a negative return value from strcmp() signify?

A negative return value indicates that the first string (s1) is lexicographically less than the second string (s2).

4. Can strcmp() be used to compare numbers or other data types?

No, strcmp() is specifically designed for comparing C-style strings (character arrays terminated by a null character). It should not be used to compare numerical data types directly. For comparing numbers, use numerical comparison operators (==, <, >, etc.).

5. Is strcmp() efficient?

strcmp() is generally efficient for comparing strings. It stops comparison as soon as a mismatch is found or the end of the strings is reached. However, for very long strings, the comparison time can increase linearly with the length of the strings in the worst case (when strings are identical or have a long common prefix).

Conclusion

The strcmp() function is an essential tool in C programming for comparing strings lexicographically. Understanding its syntax, how it works, and its case-sensitive nature is crucial for any C programmer. By mastering strcmp(), you can effectively implement string comparison logic in your programs, whether for simple equality checks, ordering strings, or more complex text processing tasks. Remember to handle the return values correctly and be aware of potential pitfalls to write robust and reliable C code.