I have a function which needs to encode strings, which needs to be able to accept 0x00 as a valid 'byte'. My program needs to check the length of the string, however if I pass in "\x00" to std::string the length() method returns 0.
How can I get the actual length even if the string is a single null character?
You're passing in an empty string. Use std::string(1, '\0') instead.
Or std::string{ '\0' } (thanks, @zett42)
std::string{ '\0' } –
Isagoge std::string with only a single char argument? –
Mantoman std::string("\0", 1), or std::string{ '\0' }. –
Favorite std::string{ 0 } or std::string(1, 0) –
Leadwort std::string is perfectly capable of storing nulls. However, you have to be wary, as const char* is not, and you very briefly construct a const char*, from which you create the std::string.
std::string a("\x00");
This creates a constant C string containing only the null character, followed by a null terminator. But C strings don't know how long they are; so the string thinks it runs until the first null terminator, which is the first character. Hence, a zero-length string is created.
std::string b("");
b.push_back('\0');
std::string is null-clean. Characters (\0) can be the zero byte freely as well. So, here, there is nothing stopping us from correctly reading the data structure. The length of b will be 1.
In general, you need to avoid constructing C strings containing null characters. If you read the input from a file directly into std::string or make sure to push the characters one at a time, you can get the result you want. If you really need a constant string with null characters, consider using some other sentinel character instead of \0 and then (if you really need it) replace those characters with '\0' after loading into std::string.
std::string("\x00") first creates a string literal of type const char[2], so at this point the size is still well known. Though this array decays into const char* which is passed to the std::string constructor. At this point the array size is "lost" because the constructor can only scan for the 1st \0 to determine the size. In theory std::string c'tor could have an overload for arrays, that would allow embedded \0 in string literal. –
Isagoge std::string("hi")). –
Stets std::string::string. Not perfect from code size perspective; you'd only have to hope the linker will omit these functions and the compiler inline their code into callers. –
Azzieb std::string (const char* s, size_t n); overload, and it can handle dynamically allocated char arrays. Calling it as my_str("\0", ARRAYSIZE("\0")); is usually a minor inconvenience. –
Upshot \0s. –
Isagoge b.push_back('\0'); instead of a.push_back('\0');. Apart from this, great answer! –
Text You're passing in an empty string. Use std::string(1, '\0') instead.
Or std::string{ '\0' } (thanks, @zett42)
std::string{ '\0' } –
Isagoge std::string with only a single char argument? –
Mantoman std::string("\0", 1), or std::string{ '\0' }. –
Favorite std::string{ 0 } or std::string(1, 0) –
Leadwort With C++14, you can use a string literal operator to store strings with null bytes:
using namespace std::string_literals;
std::string a = "\0"s;
std::string aa = "\0\0"s; // two null bytes are supported too
std::literals::chrono_literals). –
Favorite © 2022 - 2024 — McMap. All rights reserved.
strlen("\x00");for the same result. – Couchantstrlen(3)is not a C++ function. It's a C legacy function, that does not know about c++stringtype. You cannot use it withstrings but by converting thestringto a legacy Cchar *string. That way,strlen(3)doesn't know about array sizes, it only searches for the\0char and returns the difference between the pointer passed to it and the place where it found the null char. – Fatma