String Comparison in C: Pointer Equality vs. Content Equality

In C programming, string manipulation is fundamental yet prone to errors, especially for beginners. A common mistake is using the '==' operator to compare strings directly, which triggers the compiler warning 'comparison with string literals results in unspecified behaviour' and may cause program logic to fail unexpectedly. This article analyzes this issue in depth through a concrete programming example and provides solutions.

Problem Context and Code Analysis

Consider a simplified Linux shell parser that needs to parse command-line input, identifying special characters like '<', '>', and '&' to handle input/output redirection and background execution. The original code snippet is as follows:

if (args[i] == "&") // Warning location
    return -1;
else if (args[i] == "<") // Warning location
    if (args[i+1] != NULL)
        cmd_info->infile = args[i+1];
    else
        return -1;
else if (args[i] == ">") // Warning location
    if (args[i+1] != NULL)
        cmd_info->outfile = args[i+1];
    else
        return -1;

In this code, args[i] is a character pointer pointing to a substring obtained via the strtok() function. When attempting to compare it with string literals like "&" using the '==' operator, the compiler issues a warning. More critically, even if the character content is identical, the comparison may evaluate to false, leading to logical errors in the program.

Root Cause: Pointer Equality vs. Content Equality

In C, string literals such as "&" are stored in memory as character arrays terminated by a null character '\0'. When a string literal appears in code, the compiler allocates static storage for it and returns a pointer to that location. Thus, "&" itself is a pointer constant.

Using the '==' operator to compare two pointers checks whether they point to the same memory address, not whether the string contents they point to are identical. Even if two strings have the same content, if they are stored at different memory locations, pointer comparison will return false. For example:

char *str1 = "hello";
char *str2 = "hello";
// str1 == str2 is unspecified; it may be true or false depending on compiler optimizations

This is why the compiler warns of 'unspecified behaviour'—the result depends on the specific compiler implementation and memory layout, lacking portability.

Correct Approach: Using the strcmp() Function

To compare whether two strings have identical content, the standard library function strcmp() must be used. This function compares two strings character by character until a difference or null character is encountered. If the strings are identical, strcmp() returns 0; otherwise, it returns a non-zero value indicating the lexicographic relationship.

The corrected code should be:

if (strcmp(args[i], "&") == 0)
    return -1;
else if (strcmp(args[i], "<") == 0)
    if (args[i+1] != NULL)
        cmd_info->infile = args[i+1];
    else
        return -1;
else if (strcmp(args[i], ">") == 0)
    if (args[i+1] != NULL)
        cmd_info->outfile = args[i+1];
    else
        return -1;

This modification ensures comparison based on actual string content rather than memory addresses, guaranteeing logical correctness and portability.

Deep Dive into String Storage

To better understand this issue, it is essential to distinguish between different ways strings are stored:

1. String Literals: Such as "&", stored in the read-only data segment of the program with static lifetime.
2. Character Arrays: Such as char arr[] = "&";, stored on the stack or heap with modifiable content.
3. Character Pointers: Such as char *ptr = "&";, where the pointer variable is modifiable but the pointed-to string literal is not.

In the parser example, args[i] points to substrings obtained by modifying the original input string with strtok(), which reside in the original input buffer. In contrast, "&" is an independent string literal stored in a different memory region. Therefore, pointer comparison is bound to fail.

Programming Best Practices

To avoid similar string comparison errors, adhere to these best practices:

• Always use strcmp() or its variants (e.g., strncmp()) to compare string content.
• Note the return value of strcmp(): 0 indicates equality, negative means the first string is lexicographically smaller, positive means larger.
• For pointers that might be NULL, check for nullity before calling strcmp() to avoid segmentation faults.
• Consider using constants for special strings to enhance code readability and maintainability: #define AMPERSAND "&".
• During debugging, use printf("%p vs %p\n", args[i], "&") to inspect pointer address differences and deepen understanding.

Extended Discussion

Beyond strcmp(), the C standard library offers other string comparison functions, each suited to specific scenarios:

• strncmp(): Compares up to n characters, mitigating buffer overflow risks.
• memcmp(): Compares memory regions without relying on null termination.
• strcasecmp(): Case-insensitive comparison (non-standard but widely supported).

In the parser example, since single-character special symbols are compared, strcmp() is the appropriate choice. For more complex pattern matching, regular expressions or custom parsing logic might be necessary.

In summary, the core of string comparison in C lies in distinguishing between pointer equality and content equality. By correctly employing the strcmp() function, programmers can avoid undefined behavior and ensure program correctness and portability. This knowledge is not only foundational for shell parsers but also essential for all C string handling applications.