什么时候可以通过char *相等来比较C字符串？

Question

I know it doesn't make sense for two arbitrary c-strings ( const char * ) by comparing them (a == b) .

But I think that when both are defined by the SAME string literal, this is legal.

For example, here:

#include <stddef.h>

const char * const meals[] = {
    "none",
    "breakfast",
    "lunch",
    "dinner"
};

#define NO_MEALS  meals[0]
#define BREAKFAST meals[1]
#define LUNCH     meals[2]
#define DINNER    meals[3]

// i hours after midnight, hour_to_meals_map[floor(i)] is being served.
const char * hour_to_meal_map[] = {
    NO_MEALS,
    NO_MEALS,
    NO_MEALS,
    NO_MEALS,
    NO_MEALS,
    BREAKFAST, // i = 5
    BREAKFAST,
    BREAKFAST,
    BREAKFAST,
    BREAKFAST,
    BREAKFAST,
    LUNCH, // i = 11
    LUNCH,
    LUNCH,
    LUNCH,
    LUNCH,
    LUNCH,
    DINNER, // i = 17
    DINNER,
    DINNER,
    DINNER,
    DINNER,
    DINNER,
    DINNER // i = 23
};

// Returns a boolean for whether the two hours have the same meal being eaten.
int same_meal(size_t hour_one, size_t hour_two) {
    return hour_to_meal_map[hour_one] == hour_to_meal_map[hour_two];
}

(As for why you would make hour_to_meal_map map to strings rather than to indices is anyone's guess.. but I'm working on a project that is set up this way.)

Am I correct that this is legal here, and that what matters is that there is only one spot that each value is written as a literal? ( #define NO_MEALS "none" was deliberately avoided!!)

If this code is in a header file, that doesn't make a difference, does it? (I expect the standard requires that meals have identical values in each compilation unit?).

I find lots of questions from beginners asking about cases where it's pretty clear they should be using strcmp , but I can't find one that answers this particular case. Any help would be appreciated, particularly if you can point me to the right part of the C standard so I can be really sure I understand all the subtleties.

Answer 1

Comparing two strings of the same type with == or != is always legal. This is detailed in section 6.5.9 of the C standard which details Equality Operators:

2 One of the following shall hold:

• both operands have arithmetic type;
• both operands are pointers to qualified or unqualified versions of compatible types;
• one operand is a pointer to an object type and the other is a pointer to a qualified or unqualified version of void ;or
• one operand is a pointer and the other is a null pointer constant.

...

4 Two pointers compare equal if and only if both are null pointers, both are pointers to the same object (including a pointer to an object and a subobject at its beginning) or function , both are pointers to one past the last element of the same array object, or one is a pointer to one past the end of one array object and the other is a pointer to the start of a different array object that happens to immediately follow the first array object in the address space

In this case you have an array of pointers, and you assign the value of one of those pointers into another array. So if you compare two pointers and they both contain the value of (for example) meals[0] , eg the address of the string constant "none", they are guaranteed to compare equal.

What you have to watch out for is if a given string constant is used in multiple places. In that case, they're not necessarily the same.

For example, given this:

const char *s1 = "test";
const char *s2 = "test";

The values of s1 and s2 are not guaranteed to be the same as the two strings constants can be distinct from each other, although compilers may choose to make them the same. This differs from:

const char *s1 = "test";
const char *s2 = s1;

Where s1 and s2 will be the same, and this mirrors your case.

As you mentioned, it would make more sense for hour_to_meal_map to contain numeric constants (preferably members of an enum ) and for those constants to subsequently map to an array of strings. But the pointers to strings constants are effectively just that.

Answer 2

I can think of a few cases where char * equality is meaningful:

1. the case you gave: by copying from the same pointer
2. for most (all?) compilers: with any same-value string literals in the same translation unit. This is an extremely common optimization, and can easily be tested anyway.
3. if you explicitly pass the string through an intern() function
4. as a quick short-circuit comparison before performing an expensive check of the value