38

Compiling with gcc-7.1 with the flag -std=c++17, the following program raises an error:

#include <string_view>
void foo(const char* cstr) {}
void bar(std::string_view str){
    foo(str);
}

The error message is

In function 'void bar(std::string_view)':
error: cannot convert 'std::string_view {aka std::basic_string_view<char>}' to 'const char*' for argument '1' to 'void foo(const char*)'
 foo(str);

I'm surprised there is no conversion to const char* because other libraries (abseil, bde), provide similar string_view classes which implicitly convert to const char*.

Baum mit Augen
  • 46,177
  • 22
  • 136
  • 173
Justin Raymond
  • 3,043
  • 2
  • 16
  • 27
  • 1
    My mistake, [`std::std::basic_string_view::data`](http://en.cppreference.com/w/cpp/string/basic_string_view/data) does not guarantee a null terminated string. – François Andrieux Jan 03 '18 at 16:36

3 Answers3

55

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().

Rakete1111
  • 42,521
  • 11
  • 108
  • 141
  • The explanation for why std::string_view doesn't provide a conversion is great, but only offers a provisional answer to the question. – Syndog Jan 01 '19 at 14:11
  • 1
    Your recommendation about `std::string(object).data()` is a bad one, because in most cases the data will point to unallocated storage. – rems4e Feb 21 '20 at 19:59
  • 4
    @rems4e An alarm went off for me as well when I saw `std::string(object).data()` recommended without the important caveat that the returned pointer is to data inside the temporary std::string object, which lasts only til the end of the largest enclosing expression. – Don Hatch Apr 02 '20 at 07:02
40

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.

Yakk - Adam Nevraumont
  • 235,777
  • 25
  • 285
  • 465
  • 1
    by " (and clean it up at the end of the line).", I can continue use the member of that Rvalue til the end of scope that `std::string(string_view_object).c_str()` sitting, right? – sandthorn Jan 30 '18 at 10:28
  • 1
    @sandthorn No, until the end of the full expression, not scope. – Yakk - Adam Nevraumont Jan 30 '18 at 14:25
  • @sandthorn If you want the string to stick around, you'd maybe prefer `std::string TempVar(string_view_object);` then where you need it in scope, `TempVar.c_str()`. – Ruzihm Feb 24 '21 at 08:10
7

You can call foo(std::string(str).c_str()).

Maxime Guinin
  • 122
  • 5