Thread: State of string.length()

Hello! Quick question here, since I haven't gotten any good C++ reference books yet.

Is the string length calculated each time string.length() is called, or is the value always kept "up-to-date" somewhere in the object?

Thanks!
-tretton

Thank you, everyone!

Originally Posted by Ancient Dragon

Not necessarly -- capacity() is the number of byte the string class has allocated for the data. size() and length() are both the same and is the count of the number of characters up to the first 0.

Corndbee is right in saying that a std::string is allowed to contain multiple NULL bytes. There is, however, an issue that, when given standard C-style strings, that std::string member functions (constructors, assignment, etc) only copy up to the first NULL byte. If you want to get multiple NULL bytes into a std::string, you have to jump through a few more hoops, and converting such a std::string back to a C-style string will mean you don't see all the contents of the std::string.

As to whether that means that a std::string needs to store it's length, I'm not so sure, but suspect Corndbee is correct: by providing the data() method, the definition of std::string implicitly rules out implementations of std::string based on (say) a linked list of nodes, each containing a byte.

Originally Posted by Ancient Dragon

In the below example, the assignment operator changes the capacity to the number of characters including 0s in the entire string, while memcpy does not change the original allocated string's capacity.

I wouldn't expect it to, memcpy() only works with raw memory, and does not cooperate if the memory it works with happens to belong to a std::string (or any other class type, for that matter).

Originally Posted by Ancient Dragon

Code:

#include <iostream>
#include <string>
using namespace std;

int main()
{
	std::string str;
	str.resize(255);
	memcpy((char*)str.data(), "Hello\0World\0Now\0", 16);
	cout << "str.capacity() = " << str.capacity() << endl;
	cout << "str.size() = " << str.size() << endl;
	cout << "str.length() = " << str.length() << endl;
	cout << endl;

The snippet above would not change any of the members you are printing out. If you were to copy more than 255 bytes (or the string was of length 15 or less) the result would be undefined behaviour.

Originally Posted by Ancient Dragon

Code:

	str = "Hello\0World\0Now\0";
	cout << "str.capacity() = " << str.capacity() << endl;
	cout << "str.size() = " << str.size() << endl;
	cout << "str.length() = " << str.length() << endl;

	return 0;

}

output

Code:

str.capacity() = 255
str.size() = 255
str.length() = 255

str.capacity() = 31
str.size() = 5
str.length() = 5
Press any key to continue

[edit]A bit more testing shows that the assignment operator stops copying characters when it encounters the first 0 byte. So you can't use the assignment operator with strings that contain embedded null bytes.

That's the way it's supposed to be. But that doesn't mean a std::string cannot contain more than one null byte. It's just an artifact of how assignment to a C-style string works.

Originally Posted by Ancient Dragon

Changing the first 0 to a space (or some other readable character) does not change the string's length(), so the value returned by length() is an internal class integer the represents the string's length only when the std::string's contents are changed by one of std::string's method, such as one of the operators. std::string does not perform strlen() each time length() is called. [/edit]

This last observation is correct. However, try a test based on this;

Code:

#include <iostream>
#include <string>
using namespace std;

int main()
{
	std::string str;

        char temp[] = "Hello\0World\0Now\0";
	for (int i = 0; i < sizeof(temp); ++i)
           str.append(temp[i]);

	cout << "str.capacity() = " << str.capacity() << endl;
	cout << "str.size() = " << str.size() << endl;
	cout << "str.length() = " << str.length() << endl;

	return 0;

}

and you'll find the results are a bit different.

grumpy: Where did I, or any else for that matter, say std::string could not contain more than one 0?

If you were to copy more than 255 bytes (or the string was of length 15 or less) the result would be undefined behaviour.

Agree -- more than 255 characters is simply C buffer overflow behavior, but I don't see where copying less than 15 characters would be a problem when the buffer will hold up to 255 characters.

Code:

           str.append(temp[i]);

won't compile -- no append() overrides take char.

Originally Posted by Ancient Dragon

Code:

           str.append(temp[i]);

won't compile -- no append() overrides take char.

That's what I get for typing too fast rom memory rather than having the standard at hand; one of many minor anomolies in the standard.

Try

Code:

str.append(1, temp[i]);

or

Code:

str += temp[i];