std :: string声明的函数不会抱怨返回char *

Question

This is not my program so don't start berating me :-). Some random program I got. A globally declared buffer is being returned by MyFunc(). I use VS2008 and it does not complain

static char buffer[1024];

std::string MyFunc() {
    ....
    ....
    return buffer;
}

However when I add this line of code

char * ret;
ret = MyFunc() 

It complains: "error: no suitable conversion function from "std::string" to "char *" exists"

My question is why is the compiler complaining now? Why this inconstancy in syntax checking? Again I dont have the freedom to change MyFunc(). In my program if I can make

std::string ret;
ret = MyFunc(); 

and get rid of the syntax error but would really like to understand this strange behavior.

Answer 1

string() has a constructor that accepts a char*, so you get an automatic conversion. There is no automatic conversion from a string to a char*. You have to call string::c_str() to get the char*.

Edit Although you asked only for an explanation of the behavior, others in this forum seem to think I have short-changed you by not mentioning that string::c_str returns a const char*, not a simple char*. But the explanation remains: there is no implicit/automatic conversion from string to char* or const char*. Feel free to read about c_str here if it's important to you.

Answer 2

It is not the syntax, it is the structure of the std::string that makes the compiler behave differently.

When you are returning a char* from a function returning std::string , the compiler notices that there is a constructor of std::string that takes char* , calls that constructor, and quietly returns the result.

When you are trying to return a std::string from a char* - returning function, the compiler tries to see if there is a conversion operator to make char* from a std::string , finds that there is no such operator, and reports an error.

If you want to convert a string to char* , you need to make a copy of the string's buffer, like this:

char* ret_ch = new char[ret.size()+1];
memcpy(ret_ch, ret.c_str(), ret.size()+1);
return ret_ch;

You could think that it is OK to return c_str() by itself, but it is not a good idea: the buffer that "backs up" this C string belongs to std::string object, so once the string gets deallocated, accessing the buffer starts producing undefined behavior. That is why you need to make an explicit copy when you access the buffer of a string. Of course you are also responsible for calling delete[] on the copied result.

Answer 3

std::string is designed as implicitly constructable from char const* because this supports using string literals and typical C style code strings as initializer values.

If this was not supported then one would just have to use some intermediate function, which would add nothing but verbosity and inefficiency.

In the other direction, however, std::string is intentionally designed to not convert implicitly to char const* . Part of the rationale is probably that with std::string being logically mutable, the returned raw pointer is only valid as long as no operations are performed that might cause a buffer replacement or string destruction. For example,

    char const* s = foo().c_str();

where foo produces a std::string , makes s point to a buffer that no longer exists, a dangling pointer that is invalid.

The c_str() member function call makes the conversion stand out.

Consider how more common that problem could be if one could write just

    char const* s = foo();

and have that compile.

---

^{Regarding that strike-through (deleted) text, I realized that it's completely irrelevant whether the string is logically mutable or immutable. Sorry. Need more coffee!}