char数组及其指针如何在c ++中完全正常工作？

Question

I am a beginner student in c++ and there is one thing I cannot understand when working with character arrays: So, I know that pointers are essentially variables that "point" to the memory address of another variable, and that the name of an array(Ex: int a[20]) is a constant pointer to the values in that array. When working with different numeric types(int, float etc.) if we output through a message the name of that array it shows the address of the first element, but if we do the same with a char type, it doesn't show the address, but the value of the variable. Example:

#include <iostream>

using namespace std;

int main()
{int a[]={1,2,3,4,5};
cout<<a<<endl; //through output, it shows the memory address of the first 
element of the array;
char b[]={"Mountain"};
cout<<b; //It outputs the word "Mountain"
    return 0;
}

Is the pointer from a char array automatically converted to its value when you output it?

Answer 1

There is no difference. char pointers aren't somehow magically different than int pointers. So what's going on, than?

std::cout << (or the older printf() ) have overloads for char* . Meaning that the functions behave differently if the input is a char* : the pointer is iterated until a '\\0' character is reached (see null terminated string ).

---

char b[]={"Mountain"};

b does not contain

• {'M', 'o', 'u', 'n', 't', 'a', 'i', 'n'}

but instead

• {'M', 'o', 'u', 'n', 't', 'a', 'i', 'n', '\\0'} <- '\\0'

making the iterating and stopping possible.

This also explains why the array size of b is 1 larger than the number of characters inside the word.

---

To add, you should not use these char pointers. They are dangerous and are long replaced by modern utilites like std::string .

---

now int a[]={1,2,3,4,5}; is OK but std::array<int, 5> a = {1,2,3,4,5}; is even better.

• the types are unique ( std::array<int, 4> != std::array<int, 5> )
• it has a .size() function.
• you can therefore pass it to other functions without having to add a size argument
• it's as fast as a normal array

std::array can be used by including <array> .

---

If you ever go for something like int* a = new int[5]; than stop right there and instead use std::vector

---

Fianally never ever say use namespace std; ( here why )

Answer 2

It all depends on how you interpret the parameters. cout << operator will consider (sometype*) as an address, but particularly char* as a string.

If you write a function taking your own parameters, you can interpret what ever the way you like.

In this problem, if you want to get the address, you can do it so

std::cout << static_cast<const void*>(b);

Answer 3

In C, strings are represented as a pointer to char . for this reason, when you pass a char* to an ostream (such as std::cout ) in C++, it will interpret it as a null-terminated string and print that string's content rather than the address. If you want to print the address, you'll have to cast that pointer to a different kind:

std::cout << (void*)b;

Answer 4

cout is an output stream. When we use output streams, and pass a char* , it treats it as a null terminated string (ie it prints all the characters till it find '\\0') in the string. For any other pointer type, the address is printed.