Semantic of `string.length()`?

Question

I want to convert a char buffer of known size (e.g. received from socket) into a string, but with the caveat that the char array is not necessarily null-terminated.

So I tried to use string (InputIterator first, InputIterator last) constructor. However, I notice that string::length() isn't always the same as strlen, at least in my case where strings are manually crafted from buffers with many trailing zeros.

#include <string>
#include <iostream>

#include <string.h>

using namespace std;

int main()
{
    char a[20] {0};

    a[0] = 'a';
    string b(a, a + 20);
    cout << b.length() << endl;
    cout << strlen(b.c_str()) << endl;
}

Output is

20
1

Though this is a well-defined behavior for string::length (thanks to the comments and some initial answers for helping me to realize that), I'd like to find a better / more idiomatic solution.

Answer 1

The difference here is that, for a std::string, those NULL characters don't affect its length; it can hold them just fine.

However, for a c-style string, strlen with stop counting when it encounters the first NULL character, which for you is the second character, hence a size of 1.

Answer 2

You told it you wanted 20 bytes, so that's exactly what you got.

It sounds like you want to copy up to 20 bytes or until a null byte is encountered:

#include <string>
#include <iostream>
#include <cstring>

int main()
{
    char a[20]{};

    a[0] = 'a';
    std::string b(a, a + strnlen(a, sizeof(a)));
    std::cout << b.length() << '\n';
    std::cout << strlen(b.c_str()) << '\n';
}

You'll notice I've gone back to having the computer detect the number of input bytes for us, but with strnlen you can tell it to stop at 20, taking care of the problem that the array may not be null-terminated.

I've also changed {0} to {}, for style/sanity reasons.

(live demo)