Doug’s comment is spot-on.

The == operator is comparing the memory address of the first character of the string, while strcmp compares the strings character by character.

Here is some code to demonstrate:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Action()
{
  char* string1 = "hello world";
  char* string2 = "hello world";
  char buf[12];
  char* string3;
 
  strcat(buf, "hello ");
  string3 = (char*)strcat(buf, "world");
  lr_output_message("string3: %s", string3);
 
  // Print memory addresses
  lr_output_message("string1 memory address: %u", string1);
  lr_output_message("string2 memory address: %u", string2);
  lr_output_message("string3 memory address: %u", string3);
}

Here is the output from the code:

1
2
3
4
5
6
7

Starting action Action.
Action.c(12): string3: hello world
Action.c(15): string1 memory address: 28181591
Action.c(16): string2 memory address: 28181591
Action.c(17): string3 memory address: 29622316
Ending action Action.
Ending iteration 1.

string1 and string2 have the same memory address because of a compiler optimisation. The compiler can see that two character arrays have been created that are identical. It saves memory by only creating one character array in memory, and putting a reference to the first element of the array in string1 and string2.

In Java, you would use the term “string pool”. More generally, the concept is known as “string interning“, and is common to many languages/compilers.

The reason that string1==string2 is true is a product of compiler optimisation and nothing else.

The two “strings” are defined as char arrays, and the compiler will notice that they are in fact the same string. Because of the initialisation at definition the compiler will therefore create only one array in memory and will place the memory address of the start of the array in to both char pointers (string1 & string2).

In fact early C compilers did not do this optimisation and would have blindly created two arrays and put the appropriate starting memory addresses into each char pointer, and in this case string1==string2 would return false.

The reason string1==string3 is false is that the buf array is uninitialised at creation time so the compiler cannot create the buffer at the same memory location as that used to hold the “hello world” array.

The reason they never become true is that C does not have the concept of singleton string literals (or strings at all of course) that some modern languages do. So even after making the content of the buf array contain the same values, this does not move it in memory. So the start of the buf array (what is held in the pointer string3) will never be the same as the start of the array created with “hello world” in it.

Also please be aware that this should be ANSI-C not C++ so there is no concept of “objects”, a char array is just a piece of memory holding char values, and initialised with ascii zero (null) as the final character of the array in the static array between quotes so that the standard C string library functions work.

[Stuart's Reply: Nope. The strings are clearly identical when using strcmp, but using == shows inequality. Why?]

so,

string1 == string2 –> checks only whether they are same objects.(string1 and string2 are same objects)
string1 == string3 –> Here both are different objects as string 3 is a buffer.

[Stuart's Reply: Nice try, but the == operator does not compare types]

Alternatively, the == is somehow able to see the difference between how the two strings have been put together.

The big question is “Am I correct?”.

[Stuart's Reply: No, you are not correct. :) ]