为什么c++中字符arrays和integer arrays的基本属性有区别？

Question

If I execute this code:

#include<iostream>
using namespace std;

int main(){
    char str[20] = {'a','b','c','d','e'};
    cout<<str<<endl;
    return 0;
}

It outputs abcde but If I execute this code:

#include<iostream>
using namespace std;

int main(){
    int arr[20] = {1,2,3,4,5};
    cout<<arr<<endl;
    return 0;
}

It outputs 0x7fff22eecc30 I have tried executing this code in two different online compilers and they are giving same outputs.

In char array it is returning the array contents but in int array it's returning memory address. Why is that? Also, how can two different online compilers return the same memory address?

I have tried looking out online for this but I'm not sure what to look for?

Answer 1

With char str[20] = {'a','b','c','d','e'}; , the remaining 15 elements of the array are all set to 0. The special ostream overload for << that's used as a result of the array str decaying to a char* pointer to the first element of that array will output the array as if it's a C-style string, since the first 0 will act as a NUL terminator.

An equivalent way of writing the above is char str[20] = "abcde" .

In your second case, the overloaded << for ostream for a const void* pointer is used (due again to pointer decay), which prints the address of the first element of the array.

Answer 2

What std::cout knows how to print

Under the hood cout is an object derived from the basic_ostream class template. The standard library provides some functions that tell basic_ostream how to print different types of data. (Some are member functions, some aren't - but that's not important here.)

Here are some examples:

basic_ostream<charT,traits>& operator<<(bool n);
basic_ostream<charT,traits>& operator<<(short n);
basic_ostream<charT,traits>& operator<<(int n);
basic_ostream<charT,traits>& operator<<(double f);
... and more ...

These functions tell cout (and other basic output streams) how to print bools, shorts, ints, etc.

There's also these two

basic_ostream<charT,traits>& operator<<(const void* p);

template<class traits>
    basic_ostream<char,traits>& 
    operator<<(basic_ostream<char,traits>&, const char*);

The first one tells cout how to print the address of an untyped pointer (a void* ).

The second one is intended to print C-style strings --- especially literal strings in your source code. For example, cout << "Hello";

What about arrays?

The standard library doesn't provide any direct support for printing arrays (or any other collection) . If you want to print a collection, you have to decide what format you want for that collection, and code it up yourself.

This is the same for structs and classes. If you define your own class, cout doesn't know how to print it --- you must code that up yourself.

Why does your first example output "abcde"?

You're trying to print a char[20] (an array of char). basic_ostream doesn't have an overloaded << function for arrays, so it doesn't know how to print them.

BUT - C++ is allowed to implicitly cast an "array of T" to a "pointer to T", so your str variable is implicitly cast from char[20] to char* . That matches the last overload I listed above - the one that is supposed to be used for C-style strings . (Other answers have already discussed issues regarding the terminating zero that C-strings are supposed to have.)

What about the second example?

The type of arr is int[20] . Once again, cout doesn't know how to print arrays.

SO - C++ tries implicitly casting your int[20] to an int* . But there is no overload for int* , so C++ tries again. It implicitly casts the int* to a void* (which it is allowed to do) - and now it finds a match.

The void* overload prints the memory address of the pointer.

This happens with all arrays except arrays of char , signed char and unsigned char . The array of T is cast down to a pointer to T, which is cast down to a void pointer.

Why is char* treated differently than any other pointer type

Because we print C-style strings (especially string literals) a lot. Like, a lot a lot.

Answer 3

The most often usage of character arrays is the usage them as containers of strings. It is very easy to determine the size of a string due to its sentinel value that is the terminating zero character.

So if in a C program you will write for example

char str[20] = {'a','b','c','d','e'};
printf( "%s", str );

then the call of printf easy outputs the string "abcde" because it is well-knowb where to stop outputting characters of the character array.

If in a similar call of printf you will specify an integer array then it is unknown what is the size of the integer array. How many integers stored in the array to output?

So a call of printf for character arrays containing strings is well-defined. However if you are using a pointer of the type int * when it is unclear whether the pointer points to a single integer or a sequence of integers. And if the pointer points to a sequence of integers then what is the length of the sequence?

This approach was carried over to the implementation of the overloaded operator << for character arrays in C++.

Pay attention to that if a character array does not contain a string this such a statement

std::cout << str;

results in undefined behavior. In this case you should use for example the following call

std::cout.write( str, sizeof( str ) );