一维数组：
如果我们定义了一个一维数组，那么这个数组名，就是指向第一个数组元素的地址，也即，是整个数组分配的内存空间的首地址。
比如 int a[3]; 定义了一个包含三个元素的数组。因为一个int占4个字节，那么系统就会为这个数组分配12个字节的内存空间，用来存储这个数组。
可以运行下面代码来观察每个元素的地址：
int main() {
int a[3];
a[0] = 1;
a[1] = 20;
a[2] = 33;
cout << "a的地址:" << a << "\n";
for (int i = 0; i < 3; i++)
cout << &a[i] << "\n";
}运行结果：
可以看到内存的首地址是FAA8开始，注意这里的a和a[0]的地址是相等，因为它们都是代表数组的第一个地址。
然后依次加4个字节，FAAC，FAB0。
那么因此得出结论，数组名元素值每加1，它就会访问到下个四字节的地址（注意这里是根据类型的）。
那么a[3]就应该是FAB4，注意这里数组定义三个，下标是从0开始的，所以到2就结束了。
但我们依然可以通过a[3]访问到FAB4,只不过不是合法的，你不能写入，因为这不是属于你的内存。
如下例子：
#include <iostream>
using namespace std;
int main() {
int a[3];
a[0] = 1;
a[1] = 20;
a[2] = 33;
cout << "a的地址:" << a << "\n";
for (int i = 0; i < 3; i++)
cout << &a[i] << "\n";
cout << "a[3]的地址:" << &a[3] << "-------a[3]的值:" << a[3]; //访问a[3]的值，int类型4个字节
}
结果： (注意访问a[3]是不合法的，只为示例使用）
可以看到a[3]的地址，是在a[2]的基础上加了个四个字节，这就是数组的规则。其实可以看作是指针的一种运用。
所以一维数组，我们可以像定义int 变量指针来定义数组指针，如下：
#include <iostream>
using namespace std;
int main() {
int a[3];
a[0] = 1;
a[1] = 20;
a[2] = 33;
int* p = a;
cout << *p << "\n" << p[1] << "\n" << *(p + 2);
}
输出值:
这里要特别说是*(p+2)这个访问，因为指针变量不像正常变量，比如int a;
a+1的话，它就会在a的值加1， 指针变量+1的意思，是在原来的地址上，增加该类型的字节数。这个是根据指针类型来决定的。比如int类型指针加1就是，4字节的+4，+2就是8。
可以通过输出地址值来查看，比如：
int* p = a;
int* p1 = p + 1;
cout << p << "\n" << p1 << endl;二维数组：
接下来说一下二维数组
比如定义了一个int b[2][3],可以看成是什么，可以看成是我们定义了2个一维数组a[3]。我们分开来看。
那么b[0]就是一个内存地址，指向了第一个a[3]一维数组的地址。
而b[1]就是指向了第二个a[3]一维数组的首地址。
可以通过地址观察验证：
#include <iostream>
using namespace std;
int main() {
int b[2][3];
b[0][0] = 1;
b[0][1] = 20;
b[0][2] = 33;
//输出二堆数组的每个地址:
for (int i = 0; i < 2; i++)
for (int j = 0; j < 3; j++)
cout << "b[" << i << "][" << j << "]地址:" << &b[i][j]<< endl;
//输出b[0]和b[1]地址：
cout << "\n\nb[0]地址:" << b[0] << "\nb[1]地址:" << b[1] << endl;
}
结果：
可以看到定义了一个二维数组，根据地址来看，在内存中是跟一维数组同样的分配方法，依次增加，每次四个字节，F5E8，F5EC,F5F0.....
只不过是以二维的层次来解读的,通过两个下标来控制，比如b[2][3]数组，你找到规则后，你就可以像一维数组那样推断出b[4][2]是哪个地址，访问的数据段是哪里（当然同上，这种访问也是不合法的，只为示例说明）
分解出来后：
那么b[0]即b[0][0]的的首地址，这个跟前面一维数组同样的原理，a跟a[0]地址一样。
而b[1]的地址，就是要加上12个字节，即F5F4，即b[1][0]首地址。
这个12个字节，就是包含3个整数的一维数组的跨度，这不难理解，跟前面都对应上了。
所以现在问题来了：
即现在二维数组b应该是什么样的指针指向它？它加1是多少？
(推理过程，如果不适请跳过直接看结果）
现在是二维数组b包含了两个一维数组a[3];
可以把a[3]数组看成是一种元素。
那么就是b包含了两个元素。也就是看成是一维数组b[0]=元素1 b[1]等于元素2。
所以指针就像是这样 元素 *p=b 也就是 int *p[3]=b; （此元素有三个整数所以3，前面加上int 类型)
又因为[]的运算级高于*号，所以int *p[3],你这里是定义了一个指针数组，相当定义了三个指针变量.
这里提一下指针数组和数组的指针 的区别：
那么相当于int a,b,c; p[0]=&a; p[1]=&b; p[2]=&c;
指针数组是这样用的。
所以我们得给*p加上括号，让它成为一个二维数组的指针，即 int (*p)[3];
那么定义二维数组指针指向b就是 int (*p)[3]=b;
而由此可以推断，b+1也就是p+1; 它的跨度是一个a[3]的跨度 12字节。
那么现在我们来实际应用验证一下：
#include <iostream>
using namespace std;
int main() {
int b[2][3];
b[0][0] = 1;
b[0][1] = 20;
b[0][2] = 33;
b[1][1] = 66;
b[1][2] = 88;
//输出二堆数组的每个地址:
for (int i = 0; i < 2; i++)
for (int j = 0; j < 3; j++)
cout << "b[" << i << "][" << j << "]地址:" << &b[i][j]<< endl;
//输出b[0]和b[1]地址：
cout << "\n\nb[0]地址:" << b[0] << "\nb[1]地址:" << b[1] << endl;
//以上为观察对比数据
int(*p)[3] = b;
cout << "以下为二维数组指针p的用法:" << endl;
//取地址的方法：
cout << "*p是b[0]的地址，p是b的地址，所以相等(包括&b[0][0]):" << *p << "-------" << p << endl;
//取值的方法
cout << **p << endl;
cout << (*p)[0] << endl;
cout << (*p + 1)[1] << endl;
cout << p[1][2] << endl;
}结果：
注意这里的(*p+1)[1]指向的是 b[0][2] 输出的33，这是由于运行符优先级的问题。
因为要先运算*p所以得到了b[0]这个类型的地址，然后加1，就只会加4字节。即b[0][1];
然后，再加上一个[1]，就会再加4字节，实际跨度就只有8字节，正好是b[0][2]所以输出33.
类似这样：
int a[3] = { 1,20,50 };
cout << (a + 1)[1] << endl; //输出的是50
//或者指针的用法
int* pa = a;
cout << (pa + 1)[1] << endl;//跟上面一样那么，如果想访问b[1][1]该怎么做，用括号指定优先级，先运算p+1,再取地址，然后[1]。
即:(正确用法)
cout << (*(p + 1))[1] << endl;那么为什么又不是*(p + 1)[1]呢？我们可以根据优先级来计算，最终这个指向哪个地址，获取的是什么值。
p+1 可以知道，跨度为12字节，因为(p+1)所以先计算，之后[]优先级要高于*,所以 再计算[1],
这又是加1，那么(p+1)的结果仍然是一个跨度12字节的类型，再[1]，也就是再加上12字节，之后再*，它就是b[2][0]的地址，即b[2]。
地址是可以确定的，如下实验：
#include <iostream>
using namespace std;
int main() {
int b[3][3];
b[2][0] = 100;
int(*p)[3] = b;
cout << *(p + 1)[1] << endl; //结果 输出b[2][0] 100
}
那么这里还有一个问题，同样是地址，为什么加一个*号就取值取呢，为什么不是b[2]的地址呢？
这里我们要明白通过p+1 和p[1]的用法，虽然它们同样是给地址加上了12个字节，关键是[]这个运算是什么意思，也就是p+1返回的是什么，p[1]返回的是什么。
看下例代码：
#include <iostream>
using namespace std;
int main() {
int b[2][3];
int(*p)[3] = b;
cout << p + 1 << endl;
cout << p[1] << endl;
}运行结果：
地址是同样的，但是p+1 是一个二维指针的地址 返回类型是(*p)[3];
而p[1] 加12字节然后会解引一层指针，也就是一维指针 返回类类型是 int *p
所以*(p+1)输出的还是地址，此时已经退化成一维的指针。
而*p[1]则是会直接取值，(你可以将[1]的运算符看作是比p+1还多了一个解引操作，即自动将结果加了一个*)(再次划重点[1]增加的值，是根据前面的指针类型数据来增加的int *p是加4，char 加1
int (*p)[3] 是加12)
所以最终*p[1]就是b[1][0]的值。
那么这里留下个题目(*p)[1]又是哪个值? 如果你能分析出来，那么基本上你对二维数组指针有了一个比较好的了解了。
可以看到这些都是有着严格的区分和应用的，所以二维数组b,是不能用int *p这样来指向的，类型不匹配。
但int *p可以指向b[0],b[1]，本质上 b[0]是个一维数组名。那么类推三维数组也是一样的，可以依次拆分，按逻辑分解。这里就不介绍了，感兴趣的可以自行实验，乃至更多维的。
下面补充一些字符数组的说明
字符数组单个用法可以参照int类型，那么不同的一些点是字符串的处理输入和输出。
比如字符串它可以直接赋给数组在定义时：
char cs[10] = "hello";其中c[0]就是字符h,c[1]是有e，依此类推，注意这里有5个字符，但你如果定义cs[5]来接收，是会报错的，提示cs[5]容量不够，因为字符串系统会加上'\0'结尾的，表示该字符串结束。
所以'c'和"c" 单字符c和字符串的c 是不一样的，前进占一个字节，后者占两个字节(加上\0)
那么一个char指针指向c时，再输出，就会默认这个指针是个字符串，会一直输出，直到遇到\0才结束。
如下代码说明：
int main() {
char c[10] = { 'h','e','l','l','o' };
char* p = c;
char* p1 = &c[1];
cout << p << endl;
cout << p1 << endl;
cout << *p1 << endl;
}运行结果:
