I have a function which accepts a std::string&:
void f(std::string& s) { ... }
I have a const char* which should be the input parameter for that function. This works:
const char* s1 = "test";
std::string s2{s};
f(s2);
This doesn't:
const char* s1 = "test";
f({s1});
Why isn't this possible? The funny thing is that CLion IDE is not complaining, but the compiler is:
no known conversion for argument 1 from ‘<brace-enclosed initializer list>’ to ‘std::basic_string<char>&’
This has nothing to do with constructing std::string from char const*.
f expects a lvalue to a string, and by creating a temporary instance on the spot, you're providing an rvalue, which cannot be bound to a non-const lvalue reference. f(string{}) is just as invalid.
f expects an lvalue. Using an lvalue reference parameter is the way you express that in C++, but that doesn't meant hat that "f expects a reference".
std::string", or maybe "a string lvalue". I don't know any better or simpler way of saying that. An lvalue is just a particular kind of value.Your function receives a non const reference and you are passing a temporary object, which requires a copy or a const reference parameter. Two solutions, creating another function to receive the object as a rvalue reference and call the other overload within
void f(string&& s) { f(s); }
to allow temporary objects as parameter, or change your function definition to receive any object but as a constant reference
void f(const std::string& s) { ... }
One option is to change your function to take a string by value, not by reference. Then it will work. In any case, in C++11 sometimes it's preferable to pass by value, not by reference.
s1is completely unneeded given your example:std::string s2 = "test";const char*is not astd::stringso for it to even work at all a new temporary string would need to be created to pass to the function. But the function modifies the string you pass in!! So it won't accept a temporary. Non-const reference won't bind to temporaries.