C++指针数组_c++ 类指针数组

int *p[4]; //定义一个指针数组，该数组中每个元素是一个指针，每个指针指向哪里就需要程序中后续再定义了。
int (*p)[4]; //定义一个数组指针，该指针指向含4个元素的一维数组（数组中每个元素是int型）。

区分int *p[n]; 和int (*p)[n]; 就要看运算符的优先级了。
int *p[n]; 中，运算符[ ]优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组。
int (*p)[n]; 中( )优先级高，首先说明p是一个指针，指向一个整型的一维数组。

一、一维数组

1. 1. 静态 int array[100]; 　　定义了数组array，并未对数组进行初始化
   2. 静态 int array[100] = {1，2}；　　定义并初始化了数组array
   3. 动态 int* array = new int[100];  delete []array;　　分配了长度为100的数组array 
   4. 动态 int* array = new int[100](1，2); 　delete []array;　为长度为100的数组array初始化前两个元素

 

二、二维数组

1. 1. 静态 int array[10][10];　　定义了数组，并未初始化
   2. 静态 int array[10][10] = { {1,1} , {2,2} };　　数组初始化了array[0][0,1]及array[1][0,1]
   3. 动态 int (*array)[n] = new int[m][n]; delete []array;
   4. 动态 int** array = new int*[m];　for(i) array[i] = new int[n];  for(i) delete []array[i]; delete []array;    多次析构
   5. 动态 int* array = new int[m][n];  delete []array;      数组按行存储

 

三、多维数组

　　int* array = new int[m][3][4];    只有第一维可以是变量，其他维数必须是常量，否则会报错

      delete []array;       必须进行内存释放，否则内存将泄漏

 

 

四、数组作为函数形参传递

1. 1. 一维数组传递：
      1. 　　void func(int* array);
      2. 　　void func(int array[]);　　　　
   2. 二维数组传递：
      1. 　　void func(int** array);
      2. 　　void func(int (*array)[n]);　　　　　　　　　　　　　　　　　　

数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针，而且在其失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

 

 

五、字符数组

char类型的数组被常委字符数组，在字符数组中最后一位为转移字符'\0'（也被成为空字符），该字符表示字符串已结束。在C++中定义了string类，在Visual C++中定义了Cstring类。

字符串中每一个字符占用一个字节，再加上最后一个空字符。如：

char array[10] = "cnblogs";

虽然只有7个字节，但是字符串长度为8个字节。

 

也可以不用定义字符串长度，如：

char array[] = "cnblogs";

C语言中数组和指针是一种很特别的关系，首先本质上肯定是不同的，本文从各个角度论述数组和指针。

一、数组与指针的关系
数组和指针是两种不同的类型，数组具有确定数量的元素，而指针只是一个标量值。数组可以在某些情况下转换为指针，当数组名在表达式中使用时，编译器会把数组名转换为一个指针常量，是数组中的第一个元素的地址，类型就是数组元素的地址类型，如：
int a[5]={0,1,2,3,4}; 
数组名a若出现在表达式中，如int *p=a;那么它就转换为第一个元素的地址，等价于int *p=&a[0]；
再来一个：
int aa[2][5]={0,1,2,3,4,   
                      5,6,7,8,9};
数组名aa若出现在表达式中，如int (*p)[5]=aa;那么它就转换为第一个元素的地址，等价于int (*p)[5]=&aa[0]; 
但是int (*p)[5]=aa[0]; 这个就不对了，根据规则我们推一下就很明了了，aa[0]的类型是int [5]，是一个元素数量为5的整型数组，就算转化，那么转化成的是数组（int [5]）中第一个元素的地址&aa[0][0]，类型是 int *。所以，要么是int (*p)[5]=aa;要么是int (*p)[5]=&aa[0];
只有在两种场合下，数组名并不用指针常量来表示--就是当数组名作为sizeof操作符或单目操作符&的操作数时，sizeof返回整个数组的长度，使用的是它的类型信息，而不是地址信息，不是指向数组的指针的长度。取一个数组名的地址所产生的是一个指向数组的指针，而不是指向某个指针常量值的指针。
如对数组a，&a表示的是指向数组a的指针，类型是int (*) [5]，所以int *p=&a;是不对的，因为右边是一个整形数组的指针int (*)[5]，而p是一个整形指针int *；
数组的sizeof问题会在下面中仔细讨论。
二、数组与指针的下标引用
int a[5]={0,1,2,3,4}; 
如a[3]，用下标来访问数组a中的第三个元素，那么下标的本质是什么？本质就是这样的一个表达式：*(a+3)，当然表达式中必须含有有效的数组名或指针变量。
其实a[3]和3[a]是等价的，因为他们被翻译成相同的表达式（顶多顺序不同而已），都是访问的数组a中的元素3。
指针当然也能用下标的形式了，如：int *p=a; 那么p[3]就是*(p+3)，等同于3[p]（不要邪恶。。。3P，3P），同样访问数组a中的元素3。
根据这一规则，我们还能写出更奇怪的表达式，如：
int aa[2][5]={0,1,2,3,4,
                      5,6,7,8,9};
1[aa][2]，这个看起来很别扭，首先 1[aa]，就是*(1+aa)，那么1[aa][2]就是*(*(1+aa)+2)，也就是aa[1][2]。
1[2][aa]，这个就不对了，因为前半部分1[2]是不符合要求的。
当然在实际中使用这样的表达式是没有意义的，除非就是不想让人很容易的看懂你的代码。
三、数组与指针的定义和声明
数组和指针的定义与声明必须保持一致，不能一个地方定义的是数组，然后再另一个地方声明为指针。
首先我们解释一下数组名的下标引用和指针的下标应用，它们是不完全相同的，从访问的方式来讲。
int a[5]={0,1,2,3,4};
int *p=a;
对于a[3]和p[3]都会解析成*(a+3)和*(p+3)，但是实质是不一样的。
首先对于a[3]，也就是*(a+3)：
（1）把数组名a代表的数组首地址和3相加，得到要访问数据的地址，这里注意，数组名a直接被编译成数组的首地址；
（2）访问这个地址，取出数据。
对于p[3],也就是*(p+3)：
（1）从p代表的地址单元里取出内容，也就是数组首地址，指针名p代表的是指针变量的存储地址，变量的地址单元里存放的才是数组的首地址；
（2）把取出的数组首地址和3相加，得到要访问的数据的地址；
（3）访问这个地址，取出数据。
下面给出一个例子来说明若定义和声明不一致带来的问题：
设test1.cpp中有如下定义：
char s[]="abcdefg";
test2.cpp中有如下声明：
extern char *s;
显然编译是没有问题的。
那么在test2.cpp中引用s[i]结果怎样呢？如s[3]，是‘d’吗？好像是吧
下面我们对test2.cpp中的s[3]进行分析：
s的地址当然是由test1.cpp中的定义决定了，因为在定义时才分配内存空间的；
我们根据上面给出的指针下标引用的步骤进行计算
（1）从s代表的地址单元的取出内容（4个字节），这里实际上是数组s中的前4个元素，这个值是“abcd”，也就是16进制64636261h，到这一步应该就能看出来问题了；
（2）然后把取出的首地址和3相加，得到要访问的数据的地址64636261h+3，这个地址是未分配未定义的；

（3）取地址64636261h+3的内容，这个地址单元是未定义的，访问就会出错。

把数组的内容转换成指针的内容，而不是把数组的地址转换成指针的内容

下面给出分析的代码（可只需观察有注释的部分）：

test2.cpp // 运行错误 

若test2.cpp中这样声明：
extern char s[];
这样就正确了，因为声明和定义一致，访问就没问题了。
所以千万不要简单的认为数组名与指针是一样的，否则会吃大亏，数组的定义和声明千万要保持一致性。
四、数组和指针的sizeof问题
数组的sizeof就是数组的元素个数*元素大小，而指针的sizeof全都是一样，都是地址类型，32位机器是4个字节。
下面给出一些例子：
测试程序：

VS2010在32位windows7下的运行结果（VC6.0不符合标准）：
192
32
4
32
4
4
4
4
4
32
4
4
192
4
下面对程序做逐一简单的解释：
（1） sizeof(a); a的定义为int a[6][8]，类型是int [6][8]，即元素个数为6*8的二维int型数组，它的大小就是6*8*sizeof(int)，这里是192；
（2） sizeof(*a); *a这个表达式中数组名a被转换为指针，即数组第一个元素a[0]的地址，'*'得到这个地址所指的对象，也就是a[0]，总的来说*a等价于*(&a[0])，a[0]的类型int [8]，即大小为8的一维int型数组，它的大小就是8*sizeof(int)，这里是32；
（3） sizeof(&a); '&'取a的地址，类型是int (*)[6][8]，地址类型，这里大小是4；
（4） sizeof(a[0]); a[0]的类型int [8]，即大小为8的一维int型数组，它的大小就是8*sizeof(int)，这里是32；
（5） sizeof(*a[0]); *a[0]这个表达式中数组名a[0]被转换为指针，即数组的第一个元素a[0][0]的地址，'*'得到这个地址所指的元素，也就是a[0][0]，总的来说*a[0]等价于*(&a[0][0])，a[0][0]的类型是int，它的大小就是sizeof(int)，这里是4；
（6） sizeof(&a[0]); '&'取a[0]的地址，类型是int (*)[8]，地址类型，这里大小是4；
（7） sizeof(a[0][0]); a[0][0]的类型是int，它的大小就是sizeof(int)，这里是4；
（8） sizeof(&a[0][0]); '&'取a[0][0]的地址，类型是int *，地址类型，这里大小是4；
（9） sizeof(p); p的类型是int (*)[8]，指向一个元素个数为8的int型数组，地址类型，这里大小是4；
（10）sizeof(*p); *p取得p所指的元素，类型是int [8]，大小为8*sizeof(int)，这里是32；
（11）sizeof(&p); '&'取p的地址，类型是int (**) [8]，地址类型，这里大小是4；
（12）sizeof(pp); pp的类型是int (*)[6][8]，指向一个大小为6*8的二维int型数组，地址类型，这里大小为4，
（13）sizeof(*pp); *pp取得pp所指的对象，类型是int [6][8]，即元素个数为6*8的二维int型数组，它的大小就是6*8*sizeof(int)，这里是192；
（14）sizeof(&pp); '&'取pp的地址，类型是int (**)[6][8]，地址类型，这里大小是4；
五、数组作为函数参数
当数组作为函数参数传入时，数组退化为指针，类型是第一个元素的地址类型。“数组名被改写成一个指针参数”，这个规则并不是递归定义的。数组的数组会被改写为“数组的指针”，而不是“指针的指针”。
下面给出几个例子：
fun1(char s[10])
{
// s在函数内部实际的类型是char *；
}

fun2(char s[][10])
{
// s在函数内部的实际类型是char(*) [10]，即char [10]数组的指针；
}

fun3(char *s[15])
{
// s在函数内部的实际类型是char **，字符型指针的指针；
}

fun4(char(*s)[20])
{
// s在函数内部的实际类型不变，仍然是char(*) [20]，即char [20]数组的指针；
}
以上可以简单的归纳为数组作为参数被改写为指向数组的第一个元素（这里的元素可以是数组）的指针。数组作为参数必须提供除了最左边一维以外的所有维长度。我们还要注意char s[][10]和char ** s作为函数参数是不一样的，因为函数内部指针的类型不一样的，尤其在进行指针加减运算以及sizeof运算时。

数组声明后不可赋值，但可以修改。

指针声明后可以赋值，但不可以修改。用数组定义指针后，指针可以修改。

eg.char*p="hello"意思是把"hello"的地址赋给char*指针，char p[]="hello"意思是把hello\0存入内存，意思不同。

可以把数组转换成指针，但不可以把指针转换成数组。

转自：https://www.cnblogs.com/fenghuan/p/4775034.html

转自：https://www.cnblogs.com/SarahZhang0104/p/5749680.html