How to construct a `std::string` from a buffer that may or may not contain a null?

I have a buffer (for simplicity, let's say a fixed-sized array) of char that I would like to construct a std::string from. Said buffer may be null-terminated or its contents may run up to and include the very last character. If the buffer does contain one or more nulls, they should not end up in the resulting string. Copying should stop at the first null or the end of the buffer, whichever comes first.

This seems like a common enough thing to want to do, but the solution is not immediately obvious to me while looking at the std::string API.

• std::string has a constructor taking a range via const char * and a length, but happily continues past nulls and copies them into the string.
• Calling std::strlen() on the buffer before constructing the string isn't an option as strlen requires the string to be null terminated in the first place.
• We could use the above constructor to make a string containing nulls and then resize it down to just before the first null, but that wastes memory as the string will be over-allocated.

What is the best and/or idiomatic way to do this?

The answer, as with so many questions regarding the C++ standard library, is to think about the problem in terms of iterators.

std::string stringFromBuffer(const auto & buffer)
{
    return std::string(std::begin(buffer),
                       std::find(std::begin(buffer), std::end(buffer), '
std::string stringFromBuffer(const auto & buffer)
{
return std::string(std::begin(buffer),
std::find(std::begin(buffer), std::end(buffer), '\0'));
}
'));
}

std::string has a constructor taking two iterators, first and last. The string will be created by copying from first up until but not including last.

So first should obviously be the beginning of our buffer, while last should either be the first null in our buffer or one past the end of the buffer. Conveniently, that is exactly what a call to std::find searching the buffer for '\0' will return.

Here is a simple way for an array of chars of known size. It's similar to Parker's answer but is just done in the constructor argument and is specific to the question of an array of chars.

#include <algorithm> // std::find
#include <iostream>
#include <string>

int main() {
  const char c[] = {'a', 'b', 'c', 'd', 'e'}; // prints abcde
  // const char c[] = { 'a','b','
#include <algorithm> // std::find
#include <iostream>
#include <string>
int main() {
const char c[] = {'a', 'b', 'c', 'd', 'e'}; // prints abcde
// const char c[] = { 'a','b','\0','d','\0' };    // test alternate: prints ab
// const char c[] = { 'a','b','\0','d','e' };     // test alternate: prints ab
std::string s{c, std::find(c, c + sizeof c, '\0')};
std::cout << s << '\n';
return 0;
}
','d','
#include <algorithm> // std::find
#include <iostream>
#include <string>
int main() {
const char c[] = {'a', 'b', 'c', 'd', 'e'}; // prints abcde
// const char c[] = { 'a','b','\0','d','\0' };    // test alternate: prints ab
// const char c[] = { 'a','b','\0','d','e' };     // test alternate: prints ab
std::string s{c, std::find(c, c + sizeof c, '\0')};
std::cout << s << '\n';
return 0;
}
' };    // test alternate: prints ab
  // const char c[] = { 'a','b','
#include <algorithm> // std::find
#include <iostream>
#include <string>
int main() {
const char c[] = {'a', 'b', 'c', 'd', 'e'}; // prints abcde
// const char c[] = { 'a','b','\0','d','\0' };    // test alternate: prints ab
// const char c[] = { 'a','b','\0','d','e' };     // test alternate: prints ab
std::string s{c, std::find(c, c + sizeof c, '\0')};
std::cout << s << '\n';
return 0;
}
','d','e' };     // test alternate: prints ab
  std::string s{c, std::find(c, c + sizeof c, '
#include <algorithm> // std::find
#include <iostream>
#include <string>
int main() {
const char c[] = {'a', 'b', 'c', 'd', 'e'}; // prints abcde
// const char c[] = { 'a','b','\0','d','\0' };    // test alternate: prints ab
// const char c[] = { 'a','b','\0','d','e' };     // test alternate: prints ab
std::string s{c, std::find(c, c + sizeof c, '\0')};
std::cout << s << '\n';
return 0;
}
')};
  std::cout << s << '\n';
  return 0;
}