What is the difference between int and char arrays?

Question

What is the difference between int and char arrays below:

int main()
{
    int numbers[] = {2,1,3};
    char letter[] = {'a','b','\0'};
    cout<< numbers<<endl;
    cout<< letter<<endl;
}

Output:

0x22ff12 // an address
ab

Why isn't the 213 displayed ? I know the name of an array will point to the address of its first element, but why does a char array display different behavior?

Answer 1

There is no operator<< overload that takes arrays, exactly, so the arguments you pass (eg numbers and letter) undergo array-to-pointer conversion, to void* and char* respectively.

There is an overload of operator<<() that takes a const void*, and another that takes a const char*. When you call:

cout<< numbers<<endl;

the const void* version is matched, but when you call:

cout<< letter<<endl;

the const char* version is matched.

In the const void* version, the pointer is displayed, while with the const char* version, the string is displayed up to the null terminator.

Answer 2

When you print an array with cout it will print the base address of the array.

The exception is with char arrays which have been overloaded to print it as a c-string.

If you want to print the elements of the int array, you need to do it element-by-element.

Answer 3

The reason is thatoperator<< overloaded for const char* which prints each character till it encounters \0.

There is no such overload corresponds to int[N] which prints each element in it. Instead when you write cout << numbers, it invokes operator<< which is overloaded for void*, and which prints the address.

However, if you overload operator<< for T[N], then you can print it like that as well.

Here is a simple illustration:

template<typename T, size_t N>
std::ostream & operator<<(std::ostream & out, const T (&a)[N])
{
   for(size_t i = 0 ; i < N ; ++i)
      out << a[i] << ' ';
   return out;
}

int main()
{
   int numbers[] = {2,1,3};
   char letter[] = {'a','b','\0'};
   cout<< numbers<<endl;
   cout<< letter<<endl;
}

Output:

2 1 3 
a b

Demo : http://ideone.com/O4T9N

Answer 4

In C, and therefore in C++, a string is often represented by an array of chars terminated in a 0. Therefore an overloaded operator<< is provide for the class std::ostream, of which std::cout is an instance , which prints the char* as a string. There is no such common use of int arrays, nor any convention so the operator would 'know' how many elements to output, so the pointer to the array is matched to the version of operator<< which outputs any other pointer by printing its address.

Answer 5

char arrays are special because there is an overload for operator << that displays the content as a string.

All other arrays will have the address displayed by default.

Answer 6

In C/C++ an array is in fact a pointer to the first element. A pointer holds the address where a value is stored. Therefore, if you print the pointer numbers, you will get the address where the first value (2) is stored in memory.

char* is an exception, as it will behave as a string when you try to print it.

Answer 7

Your code mostly refers C. An array of char is de-facto representation of strings in C. On the other hand, an array in C is also a pointer to the memory cell (an address of the cell) that holds the first element of the array.

So, when you print out an array of characters, you in fact print out a string (because C treats it that way). When you're printing an array of integers, you're printing out the address of the first element of the array.

Answer 8

A char array contains characters.
It can be initialized like:

char arr[4]={'a','b','c','\0'};
char arr[4]={"abc"};

An integer array contains integers.
It can be initialized like:

int arr[4]={1,2,3,4};  

Answer 9

numbers is a pointer. All arrays in C++ are in fact pointers, numbers[3] just means "the value at the memory address &number+3", so you're outputting the memory address of the first element in numbers.

Answer 10

There is no reason the compiler should know where your int[] array ends, but tradition and standard libraries dictate that C strings are null terminated char[] arrays. There is no such tradition or library support for null terminated int[] arrays.

There are C++ pretty printers templates available if you need this functionality. I vaguely recall that one employs an array's bound when the type actually knows the bound, i.e. your code still won't work since you use [] not [3].

Just fyi, your code cannot be fixed by replacing the [] with a [3] inside the STL, although perhaps operator<< could be overloaded.