I have a function whose signature is:
void func(std::optional<std::string> os = std::nullopt);
(I’m aliasing std::experimental::optional until std::optional is officially available.)
However, I’m having difficulty calling it cleanly. The compiler will refuse to perform two implicit conversions (const char* ➝ std::string ➝ std::optional<std::string>) to call it with a raw C-string literal. I can do this:
func(std::string("Hello"));
And the compiler will figure that a std::optional is needed, and do the conversion. However, this is way too verbose. Thanks to C++11, I can also do this:
func({"Hello"});
While this is way better, it's still not ideal. I'd like to be able to call this function like any other that takes a std::string. Is this possible? Making the function take another parameter type is okay, as long as it behaves similarly to/is directly convertible to std::optional. Thanks.
C++14 adds a bunch of user-defined literals to the standard library in order to make code less verbose. It looks something like this:
using namespace std::string_literals; // needed
// using namespace std::literals; // also ok, but unnecessary
// using namespace std::literals::string_literals; // also ok, but why??
int main()
{
std::string str = "string"s;
^^^^^^^^
// This is a std::string literal,
// so std::string's copy constructor is called in this case
}