Is it safe to overload char* and std::string?
c++
Solution
Yes, it's safe, as long as you make it `const char*`, and actually often useful. String literals cannot be converted to `char*` since C++11 (and it was deprecated before that).
The `const char*` overload will be picked for a string literal because a string literal is a `const char[N]` (where `N` is the number of characters). Overloads have a kind of priority ordering over which one will be picked when multiple would work. It's considered a better match to perform array-to-pointer conversion than to construct a `std::string`.
Why can overloading `std::string` and `const char*` be useful? If you had, for example, one overload for `std::string` and one for an `bool`, the `bool` would get called when you passed a string literal. That's because the `bool` overload is still considered a better match than constructing a `std::string`. We can get around this by providing a `const char*` overload, which will beat the `bool` overload, and can just forward to the `std::string` overload.
Problem
I have just read about the overloading functions on a beginner book. Just out of curiosity I 'd like to ask whether it is safe to overload between char* and std::string. I played with the below code and get some result. But I was not sure whether it is an undefined behavior. ``` void foo(std::string str) { cout << "This is the std::string version. " << endl; } void foo(char* str) { cout << "This is the char* version. " << endl; } int main(int argc, char *argv[]) { foo("Hello"); // result shows char* version is invoked std::string s = "Hello"; foo(s); // result shows std::string version return 0; } ```