How you convert a std::string_view to a const char*?
A std::string_view
doesn't provide a conversion to a const char*
because it doesn't store a null-terminated string. It stores a pointer to the first element, and the length of the string, basically. That means that you cannot pass it to a function expecting a null-terminated string, like foo
(how else are you going to get the size?) that expects a const char*
, and so it was decided that it wasn't worth it.
If you know for sure that you have a null-terminated string in your view, you can use std::string_view::data
.
If you're not you should reconsider whether using a std::string_view
in the first place is a good idea, since if you want a guaranteed null-terminated string std::string
is what you want. For a one-liner you can use std::string(object).data()
.
Simply do a std::string(string_view_object).c_str()
to get a guaranteed null-terminated temporary copy (and clean it up at the end of the line).
This is required because string view doesn't guarantee null termination. You can have a view into the middle of a longer buffer, for example.
If this use case is expensive and you have proven it to be a bottleNeck, you can write an augmented string_view
that tracks if it is null terminated (basically, if it was constructed from a raw char const*
).
Then you can write a helper type that takes this augmented string_view
and either copies it to a std::string
or stores the augmented string_view
directly, and has an implicit cast-to-char const*
that returns the properly null-terminated buffer.
Then use that augmented helper type everywhere in your code base instead of string_view
, possibly augmenting string view interaction with std string as well to catch the cases where you have a view that goes to the end of the std string buffer.
But really, that is probably overkill.
A better approach is probably rewriting the APIs that take const char*
to take string_view
.
You can call foo(std::string(str).c_str())
.