comparison between string literal

This very simple code:

#include <iostream>

using namespace std;

void exec(char* option)
{
    cout << "option is " << option << endl;
    if (option == "foo")
        cout << "option foo";
    else if (option == "bar")
        cout << "opzion bar";
    else
        cout << "???";
    cout << endl;
}

int main()
{
    char opt[] = "foo";
    exec(opt);
    return 0;
}

generate two warning: comparison with string literal results in unspecified behaviour.

Can you explain why exactly this code doesn't work, but if I change

char opt[]

to

char *opt

it works, but generates the warning? Is it related to the \0 termination? What is the difference between the two declaration of opt? What if I use const qualifier? The solution is to use std::string?

Solution 1:

char arrays or char pointers aren't really the same thing as string class objects in C++, so this

if (option == "foo")

Doesn't compare the string option to the string literal "foo" it compares the address of option with the address of the string literal "foo". You need to use one of the many string comparison functions if you want to know if the option is the same as "foo". strcmp is the obvious way to do this, or you can use std::string instead of char*

Solution 2:

You can use == operator to compare strings only if you use std::string (which is a good practice). If you use C-style char*/char[] strings, you need to use C functions strcmp or strncmp.

You can also use the std::string::operator == to compare std::string with a C string:

std string foo = "foo";
const char *bar = "bar";

if (foo == bar) 
   ...

Solution 3:

The reason why it doesn't work is because the comparison does not compare strings, but character pointers.

The reason why it may work when you use char* is because the compiler may decide to store the literal string "opt" once and reuse it for both references (I am sure I have seen a compiler setting somewhere that indicates whether the compiler does this).

In the case of char opt[], the compiler copies the string literal to the storage area reserved for the opt array (probably on the stack), which causes the pointers to be different.

Renze