I've always had a question about null-terminated strings in C++/C. For example, if you have a character array like so:
char a[10];
And then you wanted to read in characters like so:
for(int i = 0; i < 10; i++)
{
cin >> a[i];
}
And lets in input the following word: questioner
as the input.
Now my question is what happens to the '\0'? If I were to reverse the string, and make it print out
renoitseuq
Where does the null-terminating character go? I thought that good programming practice was to always leave one extra character for the zero-terminating character. But in this example, everything was printed correctly, so why care about the null-terminating character? Just curious. Thanks for your thoughts!
There are cases where you're given a null-terminator, and cases where you have to ask for one yourself.
const char* x = "bla";
is a null-terminated C-style string. It actually has 4 characters - the 3 + the null terminator.
Your string isn't null-terminated. In fact, treating it as a null-terminated string leads to undefined behavior. If you were to cout << it, you'd be attempting to read beyond the memory you're allowed to access, because the runtime will keep looking for a null-terminator and spit out characters until it reaches one. In your case, you were lucky there was one right at the end, but that's not a guarantee.
char a[10]; is just like any other array - un-initialized values, 10 characters - not 11 just because it's a char array. You wouldn't expect int b[10] to contain 10 values for you to play with and an extra 0 at the end just because, would you?
Well, reading that back, I don't see why you'd expect that from a C-string as well - it's not all intuitive.
You are reading 10 chars, not a string. I assume that you also output 10 chars in reverse, so the 0-char plays no role, coz you dont use the array as string, but as an array of single chars...
char a[10] is ten characters, any of which can be a '\0'.
If you put "questioner" in there none of them are.
To get that you'd need a[11] and fill it with "questioner" and then '\0'.
If you were reversing it, you'd get the position of the first '\0' in a[?], reverse up to that and then add a null terminator.
This is a classic banana skin in C, unfortunately it still manages to get under your foot at the most inopportune of moments, even if you are all too familiar with it.
Related
When I run the example code, the wordLength is 7 (hence the output 7). But my char array gets some really weird characters in the end of it.
wordLength = word.length();
cout << wordLength;
char * wordchar = new char[wordLength]; //new char[7]; ??
for (int i = 0; i < word.length(); i++) //0-6 = 7
{
wordchar[i] = 'a';
}
cout << wordchar;
The output: 7 aaaaaaa²²²²¦¦¦¦¦ÂD╩2¦♀
Desired output is: aaaaaaa... What is the garbage behind it?? And how did it end up there?
You should add \0 at the end of wordchar.
char * wordchar = new char[wordLength +1];
//add chars as you have done
wordchar[wordLength] = `\0`
The reason is that C-strings are null terminated.
C strings are terminated with a '\0' character that marks their end (in contrast, C++ std::string just stores the length separately).
In copying the characters to wordchar you didn't terminate the string, thus, when operator<< outputs wordchar, it goes on until it finds the first \0 character that happens to be after the memory location pointed to by wordchar, and in the process it prints all the garbage values that happen to be in memory in between.
To fix the problem, you should:
make the allocated string 1 char longer;
add the \0 character at the end.
Still, in C++ you'll normally just want to use std::string.
Use: -
char * wordchar = new char[wordLength+1]; // 1 extra for null character
before for loop and
wordchar[i] ='\0'
after for loop , C strings are null terminated.
Without this it keeps on printing, till it finds the first null character,printing all the garbage values.
You avoid the trailing zero, that's the cause.
In C and C++ the way the whole eco-system treats string length is that it assumes a trailing zero ('\0' or simply 0 numerically). This is different then for example pascal strings, where the memory representation starts with the number which tells how many of the next characters comprise the particular string.
So if you have a certain string content what you want to store, you have to allocate one additional byte for the trailing zero. If you manipulate memory content, you'll always have to keep in mind the trailing zero and preserve it. Otherwise strstr and other string manipulation functions can mutate memory content when running off the track and keep on working on the following memory section. Without trailing zero strlen will also give a false result, it also counts until it encounters the first zero.
You are not the only one making this mistake, it often gets important roles in security vulnerabilities and their exploits. The exploit takes advantage of the side effect that function go off trail and manipulate other things then what was originally intended. This is a very important and dangerous part of C.
In C++ (as you tagged your question) you better use STL's std::string, and STL methods instead of C style manipulations.
I can't understand what the '\0' in the two different place mean in the following code:
string x = "hhhdef\n";
cout << x << endl;
x[3]='\0';
cout << x << endl;
cout<<"hhh\0defef\n"<<endl;
Result:
hhhdef
hhhef
hhh
Can anyone give me some pointers?
C++ std::strings are "counted" strings - i.e., their length is stored as an integer, and they can contain any character. When you replace the third character with a \0 nothing special happens - it's printed as if it was any other character (in particular, your console simply ignores it).
In the last line, instead, you are printing a C string, whose end is determined by the first \0 that is found. In such a case, cout goes on printing characters until it finds a \0, which, in your case, is after the third h.
C++ has two string types:
The built-in C-style null-terminated strings which are really just byte arrays and the C++ standard library std::string class which is not null terminated.
Printing a null-terminated string prints everything up until the first null character. Printing a std::string prints the whole string, regardless of null characters in its middle.
\0 is the NULL character, you can find it in your ASCII table, it has the value 0.
It is used to determinate the end of C-style strings.
However, C++ class std::string stores its size as an integer, and thus does not rely on it.
You're representing strings in two different ways here, which is why the behaviour differs.
The second one is easier to explain; it's a C-style raw char array. In a C-style string, '\0' denotes the null terminator; it's used to mark the end of the string. So any functions that process/display strings will stop as soon as they hit it (which is why your last string is truncated).
The first example is creating a fully-formed C++ std::string object. These don't assign any special meaning to '\0' (they don't have null terminators).
The \0 is treated as NULL Character. It is used to mark the end of the string in C.
In C, string is a pointer pointing to array of characters with \0 at the end. So following will be valid representation of strings in C.
char *c =”Hello”; // it is actually Hello\0
char c[] = {‘Y’,’o’,’\0′};
The applications of ‘\0’ lies in determining the end of string .For eg : finding the length of string.
The \0 is basically a null terminator which is used in C to terminate the end of string character , in simple words its value is null in characters basically gives the compiler indication that this is the end of the String Character
Let me give you example -
As we write printf("Hello World"); /* Hello World\0
here we can clearly see \0 is acting as null ,tough printinting the String in comments would give the same output .
I'm doing an assignment for school and I seem to have a problem with other characters being in the array. (Amongst other problems...)
In one function, I declared the array..
const int MAXSIZE = 100;
char inFix[MAXSIZE];
And this code is used to put chars into the array
//loop to store user input until enter is pressed
while((inputChar = static_cast<char>(cin.get()))!= '\n')
{
//if function to decide if the input should be stored or not
if(isOperator(inputChar) || isdigit(static_cast<int>(inputChar)) || inputChar == '(' || inputChar == ')')
{
inFix[a] = inputChar; //stores input
a++;
}
}
At the end of this, I append the null character to the array though I wasn't sure if I should do this:
inFix[MAXSIZE] = '\0';
Or if I should've used strcat.. either way... in my next function, I use strcat to append a parenthesis to the end.
But I've been having problems with the code, so I ran a for loop to print what is inside the infix array at the beginning of my next function, just to see...
And I get this annoying beeping sound, and a string of weird characters like hearts, and music signs... and.. a whole list of odd characters. What could be the problem? Thanks.
EDIT: by the way, I input 9*4, and I run the for loop after i append the parenthesis, so at the beginning of the output, I get:
9*4) and then the string of odd characters...
so I ran a for loop to print what is inside the infix array at the beginning of my next function, just to see...
And I get this annoying beeping sound, and a string of weird characters like hearts, and music signs... and.. a whole list of odd characters. What could be the problem?
The problem is that you're printing out array elements which you never initialized. The answer you have currently accepted advises you to initialize all those elements. Although this will not cause errors it is a mistake to let this answer prevent you from fully understanding the problem you encountered.
Reconsider your code where you inserted a null character at the end of the array:
inFix[MAXSIZE] = '\0';
You apparently know that a null character has something to do with marking the end of the string, but you've mistaken how to do that correctly. Everything from the beginning of the array until a null character will be treated as part of your string. If you copy three characters from the input 9*4 into your array then you should only want those three characters to be seen as part of your string. What you do not want is for everything in the array past those three characters, up to MAXSIZE to also be treated as part of your string. So you need to put the end-of-string marker, the '\0', right after the characters you care about.
(BTW, inFix[MAXSIZE] = '\0'; not only puts the end-of-string marker at the end of the array, it puts it outside the array, which you are not allowed to do. The program will behave unpredictably.)
inFix[0] = '9';
inFix[1] = '*';
inFix[2] = '4';
inFix[3] = '\0'; // <-- this is where you need to put the end-of-string marker, because this is the end of the characters you care about.
Putting the end-of-string marker at the end of the array effectively does this:
inFix[0] = '9';
inFix[1] = '*';
inFix[2] = '4';
inFix[3] = ???
inFix[4] = ???
.
.
.
inFix[98] = ???
inFix[99] = ??? // annoying bell noise? musical note symbol?
inFix[100] = '\0'; // Yes, Please!
The reason initializing the array to all zeros (which can also be done like this char inFix[MAXSIZE] = {};, empty braces instead of a 0) worked for you is because that means that no matter where you stop writing characters you care about, the next character will be a '\0'. That position, right after the characters you care about, is the only place it matters.
Since the loop that's copying the characters knows exactly where it stops it also knows exactly where to insert the end-of-string marker. It would be easy to just insert a single '\0' in the correct place.
Try appending the '\0' to position a in the array instead - that is, exactly after the last char you've read. Otherwise you're putting your characters in the array, then a random sequence of what was in the array before, and then after that is the \0 (or, in this case, it's one after the end of the array, which is even worse).
You say you null terminate string using inFix[MAXSIZE] = '\0' as you currently understand this should converted into inFix[MAXSIZE - 1] = '\0' but in this case you say that you have an string that ended in last possible character!! so how you should add something( for example a parenthesis ) to it?? because it is full and it can't accept any more characters.
So may be this is better to use inFix[a] = '\0' because you know that a point to end of string, and now if a < MAXSIZE then you have enough space to add more items to the string otherwise you may increase MAXSIZE (using strcat for example) or show some error to the user.
You declared the array with:
char inFix[MAXSIZE];
At this point in time, the content of the array is not initialized. Printing out these uninitialized characters will lead to the behavior you see (strange characters, sounds, etc.).
However, the contents of that array are not initialized. If you want to initialize this array, change this line to:
char inFix[MAXSIZE] = {0};
This initialization syntax causes the elements in the array to be initialized. The first elements are initialized to the values provided in the brackets, while any values not in the brackets will be initialized to 0. In the case above, all of the array elements will be initialized to 0 (which happens to correspond to the NULL character \0).
Since all the characters are initialized to NULL in this case, you don't need to append the null character after your input.
That said, a better solution would be not to use a C-Style array at all, but a std::vector<char>, or simply a std::string, as pointed out above.
First, I'd like to say that I'm new to C / C++, I'm originally a PHP developer so I am bred to abuse variables any way I like 'em.
C is a strict country, compilers don't like me here very much, I am used to breaking the rules to get things done.
Anyway, this is my simple piece of code:
char IP[15] = "192.168.2.1";
char separator[2] = "||";
puts( separator );
Output:
||192.168.2.1
But if I change the definition of separator to:
char separator[3] = "||";
I get the desired output:
||
So why did I need to give the man extra space, so he doesn't sleep with the man before him?
That's because you get a not null-terminated string when separator length is forced to 2.
Always remember to allocate an extra character for the null terminator. For a string of length N you need N+1 characters.
Once you violate this requirement any code that expects null-terminated strings (puts() function included) will run into undefined behavior.
Your best bet is to not force any specific length:
char separator[] = "||";
will allocate an array of exactly the right size.
Strings in C are NUL-terminated. This means that a string of two characters requires three bytes (two for the characters and the third for the zero byte that denotes the end of the string).
In your example it is possible to omit the size of the array and the compiler will allocate the correct amount of storage:
char IP[] = "192.168.2.1";
char separator[] = "||";
Lastly, if you are coding in C++ rather than C, you're better off using std::string.
If you're using C++ anyway, I'd recommend using the std::string class instead of C strings - much easier and less error-prone IMHO, especially for people with a scripting language background.
There is a hidden nul character '\0' at the end of each string. You have to leave space for that.
If you do
char seperator[] = "||";
you will get a string of size 3, not size 2.
Because in C strings are nul terminated (their end is marked with a 0 byte). If you declare separator to be an array of two characters, and give them both non-zero values, then there is no terminator! Therefore when you puts the array pretty much anything could be tacked on the end (whatever happens to sit in memory past the end of the array - in this case, it appears that it's the IP array).
Edit: this following is incorrect. See comments below.
When you make the array length 3, the extra byte happens to have 0 in it, which terminates the string. However, you probably can't rely on that behavior - if the value is uninitialized it could really contain anything.
In C strings are ended with a special '\0' character, so your separator literal "||" is actually one character longer. puts function just prints every character until it encounters '\0' - in your case one after the IP string.
In C, strings include a (invisible) null byte at the end. You need to account for that null byte.
char ip[15] = "1.2.3.4";
in the code above, ip has enough space for 15 characters. 14 "regular characters" and the null byte. It's too short: should be char ip[16] = "1.2.3.4";
ip[0] == '1';
ip[1] == '.';
/* ... */
ip[6] == '4';
ip[7] == '\0';
Since no one pointed it out so far: If you declare your variable like this, the strings will be automagically null-terminated, and you don't have to mess around with the array sizes:
const char* IP = "192.168.2.1";
const char* seperator = "||";
Note however, that I assume you don't intend to change these strings.
But as already mentioned, the safe way in C++ would be using the std::string class.
A C "String" always ends in NULL, but you just do not give it to the string if you write
char separator[2] = "||". And puts expects this \0 at the ned in the first case it writes till it finds a \0 and here you can see where it is found at the end of the IP address. Interesting enoiugh you can even see how the local variables are layed out on the stack.
The line: char seperator[2] = "||"; should get you undefined behaviour since the length of that character array (which includes the null at the end) will be 3.
Also, what compiler have you compiled the above code with? I compiled with g++ and it flagged the above line as an error.
String in C\C++ are null terminated, i.e. have a hidden zero at the end.
So your separator string would be:
{'|', '|', '\0'} = "||"
Can some one tell me what's wrong with this code???
char sms[] = "gr8";
strcat (sms, " & :)");
sms is an array of size 4 1. And you're appending more char literals, which is going outside of the array, as the array can accommodate at max 4 chars which is already occupied by g, r, 8, \0.
1. By the way, why exactly 4? Answer : Because that there is a null character at the end!
If you mention the size of array as shown below, then your code is valid and well-defined.
char sms[10] = "gr8"; //ensure that size of the array is 10
//so it can be appended few chars later.
strcat (sms, " & :)");
But then C++ provides you better solution: use std::string as:
#include <string> //must
std::string sms = "gr8";
sms += " & :)"; //string concatenation - easy and cute!
Yes, there is no room for the extra characters. sms[] only allocates enough space to store the string that it is initialized with.
Using C++, a much better solution is:
std::string sms = "gr8";
sms += " & :)";
You're copying data into unallocated memory.
When you do this: char sms[] = "gr8"; you create a char array with 4 characters, "gr8" plus the 0 character at the end of the string.
Then you try to copy extra characters to the array with the strcat call, beyond the end of the array. This leads to undefined behaviour, which means something unpredictable will happen (the program might crash, or you might see weird output).
To fix this, make sure that the array that you are copying the characters to is large enough to contain all the characters, and don't forget the 0 character at the end.
In C, arrays don't automatically grow.
sms has a specific length (4, in this case - three letters and the terminating NULL). When you call strcat, you are trying to append characters to that array past its length.
This is undefined behavior, and will break your program.
If instead you had allocated an array with a large enough size to contain both strings, you would be okay:
char sms[9] = "gr8";
strcat (sms, " & :)");
C++ has the (basically) the same restrictions on arrays that C does. However, it provides higher level facilities that make it so you don't have to deal with arrays a lot of the time, such as std::string:
#include <string>
// ...
std::string sms = "gr8";
sms += " & :)";
The reason this is nicer is that you don't have to know ahead of time exactly how long your string will be. C++ will grow the underlying storage in memory for you.
Buffer overflow for character array followed by crash somewhere!
Your sms buffer is only 4 characters long. strcat will copy 5 more characters over the end of it and corrupt the stack.