C++ - char array and the null character

Question

I have two questions about char array.

1. from the code bellow, since arr is const, why doesn't the compiler give me an error since I'm rewriting it?

   char arr[5]; // arr is a const pointer to (*)[5] array
   cin>>arr; //   
   

2. when I initialized a char array like this:

   char arr[5]={'h','i'};
   

   if I did this:

   cout << arr << "something here \n"; 
   

   it will print hisomething here. I thought It should print out

   hi   something here
   

   with 3 witespaces.

   But if I did this:

   for(int i = 0; i < 5; i++){
     cout << arr[i];
   }
   

   it will printout the 3 whitespaces.

The second case seems to prove that the compiler doesn't add any null characters. So how can the compiler ignore the 3 whitespaces?

Answer 1

1. This array is not const, because there is no const qualifier.
2. If you don't specify remaining values in initializer list, they will be initialized to 0. 0 is used to terminate C strings, not as a whitespace.

As for your claim, that for(int i=0;i<5;i++){ cout << arr[i]; } printed whitespace - how did you checked that?

For me:

#include <iostream>

int main(){
    char arr[5]={'h','i'};
    for(int i=0;i<5;i++){ std::cout << arr[i]; }
    std::cout << "X" << std::endl;
}

prints:

hiX

and hexdumped:

$ ./t | hexdump -Cv
00000000  68 69 00 00 00 58 0a                              |hi...X.|
00000007

There are '\0' chars printed. Their display seems to be operating system dependent. But they are not a whitespace.

Answer 2

1. arr itself is a "char[5]" not a "const char (*)[5]". And it is implicitly cast to a "char *" rvalue when you write cin >> arr. It's not a const because it is not even a lvalue.

And "const char *" or "char const *" mean the lvalue pointed to cannot be changed, while "char * const" means the pointer lvalue itself cannot be change. But this has nothing to do with you question, though.

1. First, there was no whitespace. And it is cin appended the null character.

---

An array is just an array:

char a[5]; //a's type is char[5];

But an array can hardly be an operand. Only operators I can remember that accept array type are sizeof and &(address-of) (On the other hand, this means sometimes a have to be an array. Or else if you write sizeof(a), it will give you the size of a pointer.). For other operations a is converted to a char * rvalue. And yes, even when you write a[0], a[1], etc. a[0] is equivalent to *(a + 0), which operates on pointers but not arrays.

When you cannot assign to something, it doesn't always mean that thing is "const":

1. You cannot assign to a const variable of course.
2. You can only assign to a variable(or aka lvalue), so you cannot assign something to a rvalue(or aka value). So you cannot write 1 = 2, because 1 is an rvalue not a variable, not because 1 is "const".
3. You must assign something to a variable that matches its type. So if you have a const char *p and a char *q, you cannot write q = p. Their types don't match. And again, it doesn't mean q is const, for it's obviously not. But you can write p = q, because char * can be implicitly cast to const char *. But const char * have to be cast to char * explicitly.

Answer 3

arr acts a const pointer which means that you cannot set the pointer to another address. It is not a pointer to a const so you can change the data at the address the pointer points to.

Example:

arr=&another_variable; //Illegal
*arr='A';              //Legal

Answer 4

1. the first it is not const. the second, this code is not safe.
2. u should to setup termination symbol '\0' in the end.

You should not use a char type, try to use string instead char array.