C语言中数组名到底是什么？

一般情况下，C语言中数组名在表达式中被解读为指向数组首元素的指针

C语言中数组名在表达式中被解读为指向数组首元素的指针，即数组名在表达式中值为数组首元素的地址。(但有个例外，int a[2];int (*pa)[2]; pa=&a;数组名前加&，取得“指向数组的指针”，这时a不解读为指向数组首元素的地址)。根据ANSI C的定义，在数组前加上&，可以取得“指向数组的指针”。
例如，int a[2];在表达式中a表示数组首元素地址；
再例如，int a[3][2];在表达式中a仍然表示数组首元素的地址，不过此时数组a的基本元素是int[2]，因此a+1每次会增加基本元素int[2]的大小。

C语言中不存在多维数组，只存在数组的数组，所谓的多维数组是便于理解提出的一种说法而已。
C语言中数组类型是包含元素个数的。

示例1：

#include <stdio.h>int main()
{int a[3][2] = { 0 };for (int i = 0; i != 3; ++i){for (int j = 0; j != 2; ++j){printf("a[%d][%d]: %p\t",i,j,&a[i][j]);}printf("\n");}printf("\n");printf("&a + 1: %p\n", &a + 1); // 实际相对于a[0][0]地址增加了3*2*sizeof(int)=24printf("a + 1: %p\n", a + 1);   // 实际相对于a[0][0]地址增加了2*sizeof(int)=8printf("\n--------------------------------------------\n\n");int b[3] = { 0 };printf("&b[0]: %p\n", &b[0]);   // 数组b首元素地址printf("&b + 1: %p\n", &b + 1); // 实际相对于b[0]地址增加了3*sizeof(int)=12printf("b + 1: %p\n", b + 1);   // 实际相对于b[0]地址增加了sizeof(int)=4return 0;
}

输出的结果可能是：

图1 结果示意

示例2：

#include <stdio.h>int main() {int arr[5] = { 1,2,3,4,5 };int(*parr)[5];parr = &arr;  // parr只有一个元素，即arrfor (int i = 0; i != 5; ++i){// (*(parr+0))[i] += 1;// (*parr)[i] += 1;parr[0][i] += 1;  // 很容易错写成parr[i] += 1;}for (int i = 0; i != 5; ++i){// printf("%d\n", (*parr)[i]);printf("%d\n", parr[0][i]);  // 输出结果为2 3 4 5 6}
}

C语言指针和数组同阶

所谓阶是方便理解自己发明的名词。
指针和数组同阶是指使用数组名的地方可以直接替换为指针。
如果数组作为指针（所指向的数组）的一个元素，则指针是数组的高阶。此时，称指针是高阶指针，数组是低阶数组。【注意不同颜色数组的含义】【此时指针是数组指针】
（不讨论其它诸如低阶指针、高阶数组的情况）。

题外话，C语言中用英语的规则阅读复杂数据类型便于理解。
例如，int a[3];表示a是数组，该数组的元素是int类型。用英语阅读则是：a is array of int。
再例如，int a[3][2];表示a是数组（元素个数2，元素类型int）的数组（元素个数3，元素类型int[2]），数组a的元素还是数组（int [2]）。因此在表达式中a仍然表示指向数组首元素（类型是int[2]）的地址，类型为int(*)[2]。用英语阅读则是：a is array(元素个数3，元素类型int[2]) of array(元素个数2，元素类型int)。

指针和数组同阶示例1：

#include <stdio.h>/* num表示数组指针p指向的数组包含的元素个数,类比成所谓的多维数组的行数 */
void triple(int (*p)[2], int num)
{for (int i = 0; i != num; ++i){for (int j = 0; j != 2; ++j){p[i][j] *= 3;}}
}int main()
{/* C语言不存在多维数组.数组a有三个元素每个元素是int[2]类型 */int a[3][2] = { {1,2},{3, 4},{ 5,6 }};for (int i = 0; i != 3; ++i){for (int j = 0; j != 2; ++j){printf("%d\t", a[i][j]);}printf("\n");}printf("---------------\n");/* 在表达式中数组名表示数组首元素的地址,a的元素类型是int[2],指向int[2]类型的指针的类型是int(*)[2],即在表达式中a表示函数triple()第一个参数的类型 */triple(a, 3);  // 数组a与triple()的第一个参数p是同阶的,同阶指针赋值法是将数组名直接赋值给指针for (int i = 0; i != 3; ++i){for (int j = 0; j != 2; ++j){printf("%d\t", a[i][j]);}printf("\n");}return 0;
}

输出结果：

图2 结果示意

指针和数组同阶示例2：

#include <stdio.h>int main() {int arr[5] = { 1,2,3,4,5 }; // 低阶数组int(*parr)[5];              // 高阶指针parr = &arr;                // 高阶指针赋值法,将低阶数组的地址赋给高阶指针for (int i = 0; i != 5; ++i){// (*(parr+0))[i] += 1;// (*parr)[i] += 1;parr[0][i] += 1;  // 很容易错写成parr[i] += 1;}for (int i = 0; i != 5; ++i){// printf("%d\n", (*parr)[i]);printf("%d\n", parr[0][i]);  // 输出2 3 4 5 6}return 0;
}

指针和数组同阶示例3：

#include <stdio.h>int main() {int arr[5] = { 1,2,3,4,5 };  // arr是parr的同阶数组int *parr;                   // parr是arr的同阶指针parr = arr;                  // parr与arr是同阶的.同阶指针赋值法,将数组名直接赋给指针for (int i = 0; i != 5; ++i){parr[i] += 1;}for (int i = 0; i != 5; ++i){printf("%d\n", parr[i]);  // 输出2 3 4 5 6}return 0;
}

指针和数组同阶示例4：

#include <stdio.h>int main()
{int b[4] = { 0,1,2,3 };int c[4] = { 4,5,6,7 };int(*p)[4] = malloc(sizeof(int)*4*2);for (int j = 0; j < 2; ++j){for (int i = 0; i < 4; ++i){if (j == 0){p[j][i] = b[i];}if (j == 1){p[j][i] = c[i];}}}for (int i = 0; i < 2; ++i){printf("%d %d %d %d \n", p[i][0], p[i][1], p[i][2], p[i][3]); // 输出：0 1 2 3 }// 输出：// 0 1 2 3 // 4 5 6 7 free(p);return 0;
}

传参示例：

#include <iostream>
#include <typeinfo>
/*编译环境：cmake -G "Visual Studio 15 2017" -A x64 ..
*/
namespace test_hybrid
{void testPointArray(){int a[2][3] = {-1,-2,-3,1,2,3};int (*p)[3] = a; // p是数组指针,每加1步进a的一个元素个大小,即3*sizeof(int);(注意多维数组是数组的数组,即a的每个元素是int[3])for(int i = 0; i < 3; ++i){// 可能的输出p[0] = 00000000001BF7C8, p[1] = 00000000001BF7D4, p[2] = 00000000001BF7E0,std::cout << "p[" << i << "] = " << p[i] << ", ";}std::cout << std::endl;// p = a[1];  // error C2440: “=”: 无法从“int [3]”转换为“int (*)[3]”p = &a[1];for(int i = 0; i < 3; ++i){std::cout << "(*p)[" << i << "] = " << (*p)[i] << ", ";}std::cout << std::endl;      }void testFunc1(int(*p)[3], int size){std::cout << "&p is: " << &p << std::endl;   // 可能的输出: 0133F86C,与&a不同std::cout << "&(p[0]) is: " << &(p[0]) << std::endl; // 可能的输出: 0133F880,与&a相同for(int i = 0; i < size; ++i){for(auto it: p[i]){std::cout << it << ", ";}}std::cout << std::endl;}void testFunc2(int **p){std::cout << "Entering testFunc2()...\n";}auto main() -> void {std::cout << "testing hybrid..." << std::endl;testPointArray();int a[2][3] = {-1,-2,-3,1,2,3};std::cout << "&a is: " << &a << std::endl;  // 可能的输出: 0133F880testFunc1(a, sizeof(a) / sizeof(a[0]));// testFunc2(a); // [ERROR]error: cannot convert 'int (*)[3]' to 'int**'auto b = a;std::cout << "type(b): " << typeid(b).name() << std::endl;  // int (* __ptr64)[3]int a2[] = {1,2,3,4};auto c = a2;std::cout << "type(c): " << typeid(c).name() << std::endl;  // int * __ptr64auto &d = a2;std::cout << "type(d): " << typeid(d).name() << std::endl;  // int [4]}
}

输出：

testing hybrid...
p[0] = 000000F287F9F978, p[1] = 000000F287F9F984, p[2] = 000000F287F9F990,
(*p)[0] = 1, (*p)[1] = 2, (*p)[2] = 3,
&a is: 000000F287F9FA08
&p is: 000000F287F9F9E0
&(p[0]) is: 000000F287F9FA08
-1, -2, -3, 1, 2, 3,
type(b): int (* __ptr64)[3]
type(c): int * __ptr64
type(d): int [4]