When do you need a null terminated string in a read-only scenario?

Question

I've been playing around with the std::string_view library and I have been contemplating on changing a code base I have been working on to use std::string_view as much as possible. However, in many of the threads that I have read on the subject of when and where to use std::string_view instead of const std::string &. I have seen many answers say, "When you don't need a null terminated string." So as I began searching around the web for, "when do you need a null terminated string?" I haven't really come across any helpful answers on the subject.

I can think of an example of an external library that you will link to that requires a std::string. And in that case you would need a null terminated string since that library requires it. I guess another example would be if you need to modify the string itself, but then we wouldn't pass it by const & if we needed to modify it.

So when would you need to use a null terminated string?

Links that I have looked at:

1. How exactly is std::string_view faster than const std::string&?
2. When would I pass const& std::string instead of std::string_view?
3. Why only string view?
4. Is there sense in using const std::string& arguments in C++17?

Answer 1

When do you need a null terminated string?

You need a null terminated string whenever the API that you use says that you need it. This requirement is ubiquitous in C interfaces and not explicitly stated in some documentation. If a function argument is a char* (possibly to const), and there is no length argument, you should assume the requirement unless documentation says otherwise.

Let's take the function execve (from POSIX standard) as an example:

int execve(const char *pathname, char *const argv[], char *const envp[]);

If you pass a non-null terminated argument as pathname, then the behaviour of your program will be undefined.

Answer 2

It's actually pretty easy to know. If you are calling a function that just takes a c-string (char*/const char*), then you need a null terminated string as that is the only way to know where then end of the string is.

If you instead have a function that takes a char*/const char* plus the size, or just two pointers marking the beginning and end of the data, then you don't need a null terminated string since you have/can get the string size without iterating to a null terminator.