null-terminated

For regular C strings, a null character '\0' signifies the end of data. What about std::string , can I have a string with embedded null characters? Yes you can have embedded nulls in your std::string . Example: std::string s; s.push_back('\0'); s.push_back('a'); assert(s.length() == 2); Note: std::string 's c_str() member will always append a null character to the returned char buffer; However, std::string 's data() member may or may not append a null character to the returned char buffer. Be careful of operator+= One thing to look out for is to not use operator+= with a char* on the RHS. It

If the array was null-terminated this would be pretty straight forward: unsigned char u_array[4] = { 'a', 's', 'd', '\0' }; std::string str = reinterpret_cast<char*>(u_array); std::cout << "-> " << str << std::endl; However, I wonder what is the most appropriate way to copy a non null-terminated unsigned char array, like the following: unsigned char u_array[4] = { 'a', 's', 'd', 'f' }; into a std::string . Is there any way to do it without iterating over the unsigned char array ? Thank you all. std::string has a constructor that takes a pair of iterators and unsigned char can be converted (in

I am communicating with a server who needs null terminated string How can I do this smartly in C#? Thorarin I assume you're implementing some kind of binary protocol, if the strings are null terminated. Are you using a BinaryWriter ? The default BinaryWriter writes strings as length prefixed. You can change that behavior: class MyBinaryWriter : BinaryWriter { private Encoding _encoding = Encoding.Default; public override void Write(string value) { byte[] buffer = _encoding.GetBytes(value); Write(buffer); Write((byte)0); } } Then you can just write any string like this: using (MyBinaryWriter

Just wondering why this is the case. I'm eager to know more about low level languages, and I'm only into the basics of C and this is already confusing me. Do languages like PHP automatically null terminate strings as they are being interpreted and / or parsed? From Joel's excellent article on the topic: Remember the way strings work in C: they consist of a bunch of bytes followed by a null character, which has the value 0. This has two obvious implications: There is no way to know where the string ends (that is, the string length) without moving through it, looking for the null character at

When terminating a string, it seems to me that logically char c=0 is equivalent to char c='\0' , since the "null" (ASCII 0) byte is 0 , but usually people tend to do '\0' instead. Is this purely out of preference or should it be a better "practice"? What is the preferred choice? EDIT: K&R says : "The character constant '\0' represents the character with value zero, the null character. '\0' is often written instead of 0 to emphasize the character nature of some expression, but the numeric value is just 0 . http://en.wikipedia.org/wiki/Ascii#ASCII_control_code_chart Binary Oct Dec Hex Abbr