Comparing std::string with constants vs comparing char arrays with constants In C++

Question

I am trying to make a little text adventure to get a handle on C++.

cin >> keyboard1;  
if ((keyboard1 == "inv")inventory(inv);  

This will work if keyboard1 is a string, but won't if it's a char array, is this because I haven't included the null at the end of the constant?

Answer 1

Let'say your code is the following:

int main(int argc, char *argv[])
{
    std::string s;
    std::cin >> s;
    std::cout << s << std::endl;
    if (s == "inv") {
        std::cout << "Got it" << std::endl;
    }
    return 0;
}

This works as expected because of the way the stl class string overrides the == operator.

You cannot expect the following code to work instead:

int main(int argc, char *argv[])
{
    char *s = (char *)calloc(10, sizeof(char));
    std::cin >> s;
    std::cout << s << std::endl;
    if (s == "inv") {
         std::cout << "Got it" << std::endl;
    }
    return 0;
}

because you are comparing s, which is the address where the string starts to a constant string (which, by the way, is automatically null-terminated by the compiler).

You should use strcmp to compare "c-strings":

int main(int argc, char *argv[])
{
    char *s = (char *)calloc(10, sizeof(char));
    std::cin >> s;
    std::cout << s << std::endl;
    if (strcmp(s, "inv") == 0) {
        std::cout << "Got it" << std::endl;
    }
    return 0;
}

This works.

Answer 2

No, the reason it won't work is because you will be comparing the address of the memory that represents each string. Use strcmp / wcscmp instead.

The reason why comparing a string and a constant work is because the string class will have an equality operator defined (eg bool StringClass:operator==(const char* pszString) ).

Answer 3

If keyboard1 is a char array, then if (keyboard1 == "inv") is performing a simple pointer comparison (both become char* ).

When keyboard1 is a string, it can call an operator==(cosnt string&, const char*) if one exists, otherwise, if the string has the non-explicit constructor string(const char *s) , the constant "inv" would be implicitly converted to a string object, and operator==(const string&,const string&) applied.