why do you need to add one on new char (str.length())? - c++

Question

Code:
string str = "Whats up";
char *c = new char[str.length() + 1];
I can still write char *c = new char[str.length()];
What is the point of adding +1 on length?

Answer 1

Your code:
string str = "Whats up";
char *c = new char[str.length() + 1];
Your question:
What is the point of adding +1 on length?
The real question should be: What is the point of using C-style strings at all in your C++ program? Are you sure you need them?
Let me explain what exactly happens in your two code lines:
"Whats up" is a string literal, i.e. a constant series of characters, a char const[9] to be precise. The 9th character is the null character, '\0', automatically added by the compiler. So the array actually looks like this:
{ 'W', 'h', 'a', 't', 's', ' ', 'u', 'p', '\0' }
In fact, you could as well write:
char const array[9] = { 'W', 'h', 'a', 't', 's', ' ', 'u', 'p', '\0' };
std::string s = array;
So you have a char const[9] array which is used to initialize a std::string. Which constructor of std::string is actually used here? If you take a look at http://en.cppreference.com/w/cpp/string/basic_string/basic_string, you will find this one:
basic_string( const CharT* s,
const Allocator& alloc = Allocator() );
Remember, std::string is actually a typedef for std::basic_string<char>, so your CharT in this case is a char, and the constructor reads as:
string( const char* s,
const Allocator& alloc = Allocator() );
Also ignore the alloc parameter. It's too complicated to explain to a beginner, and it has a default argument precisely so that you can ignore it almost all the time. Which means that you end up with:
string( const char* s);
Which is itself another way of writing:
string(char const *s);
So you can initialize std::string with a char const *, and your code passes the constructor a char const[9]. This works because the array is automatically converted to a pointer to its first element.
So std::string takes your array, treats it as a pointer and copies the 9 characters. The array size information, 9, is lost, but it doesn't matter, because you have the terminating '\0', so the std::string knows where to stop.
So far, so good. You have a std::string object which contains a copy of "Whats up". Your next line goes like this:
char *c = new char[str.length() + 1];
First of all, consider str.length(). The length function returns string size, not array size. So although you passed 9 characters to construct the string, length returns 8. This makes sense, because std::string is designed to let you forget about pointers, arrays and memory operations. It's text, and the text here has 8 characters.
Thus, str.length() + 1 equals 8 + 1 = 9, so your line of code is equivalent to:
char *c = new char[9];
You have created a pointer named c, initialised to point to a memory location where there is enough room for 9 characters, although what's currently stored there is undefined, so you must not try to read from there yet:
c
|
|
+------+
|
v
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
...| | | | | | | | | | | | ...
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
0 1 2 3 4 5 6 7 8
And there is no relationship between the std::string you created and the memory c points to. They live in completely different places:
c
|
|
+------+
|
v 0 1 2 3 4 5 6 7 8
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
... | | | | | | | | | | | | ... |W |h |a |t |s | |u |p |\0| ...
+-+-+-+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
0 1 2 3 4 5 6 7 8 ^
|
|
str -------( c_str() )-----------+
But if you use a C function like strcpy to copy the contents of the std::string to those 9 characters, then it becomes clear why you need space for 9 characters:
strcpy(c, str.c_str());
strcpy looks at the source (str.c_str()) and copies one character after the other to c until it finds '\0'. str internally ends with \0, so all is good. The function goes from 0 to 8 on the right of this picture and copies everything to 0 to 8 on the left.
And this finally answers your question: There must be space for 9 characters on the left. Otherwise, strcpy will attempt to write the final character (\0) to a memory location you are not allowed to touch. Which results in undefined behaviour and may cause e.g. crashes or random crashes.
With room for 9 characters, strcpy finished successfully:
c
|
|
+------+
|
v 0 1 2 3 4 5 6 7 8
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
... | |W |h |a |t |s | |u |p |\0| | ... |W |h |a |t |s | |u |p |\0| ...
+-+-+-+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
0 1 2 3 4 5 6 7 8 ^
|
|
str -------( c_str() )-----------+
Moral of the story:
Use std::string. Copying a std::string may use very similar mechanism inside but frees you (among other annoying things) from having to remember the "+ 1" rule:
std::string s1 = "Whats up";
std::string s2 = "...";
s2 = s1;

Answer 2

Unlike std::string, C-style strings use a special character to indicate its end, which is the null character '\0', the extra one character is used to store the terminating '\0'.

Answer 3

There is a flaw in your code.
It should be
c* = new char[str.length()+1];
s.length()+1 wouldn't do anything.
Although the compiler will automatically set the c string size for you, it's good practice to specify the exact size so you get to see the mechanics of everything.
C strings always need one more space than the std::string value because c strings are character arrays that have a terminating null value at the end of the array. That is why you always give room for the NULL at the end.