C语言指针详述(2):数组与指针

怼烎@ 2022-09-29 04:14 177阅读 0赞

第六章 数组和指针的关系  
  
1.指针数组：一个数组里存放的都是同一个类型的指针，通常我们把他叫做指针数  
  
  
组。  
  
  
int \* a\[10\];它里边放了１０个int \* 型变量，由于它是一个数组，已经在栈区分配了１  
  
  
０个(int \* )的空  
  
  
间，也就是３２位机上是４０个byte,每个空间都可以存放一个int型变量的地址，这个  
  
  
时候你可以为这  
  
  
个数组的每一个元素初始化，或者单独做个循环去初始化它。  
  
  
一个指针数组中的指针可以为任何同一类型，例如可以为结构指针、函数指针等  
  
struct a  
  
\{  
  
int a;  
  
  
int b;  
  
\}  
  
typedef struct a STRUCTA  
  
  
STRUCTA\* b\[4\];//一个存放了4个STRUCTA\*型指针的数组，其大小为4\*sizeof  
  
  
(STRUCTA\*)=16  
  
  
typedef void(\*FUNC)();  
  
  
FUNC funarr\[4\];//定义了一个函数指针数组  
  
  
2.结构数组  
  
struct a  
  
\{  
  
int a;  
  
int b;  
  
\}a\[12\];//定义了一个结构数组，大小为12\*sizeof(struct a) = 48;  
  
  
3.数组指针　： 一个指向一维或者多维数组的指针；  
  
  
int (\*b2) \[20\]; //二级指针；b2指向一个大小为20\*sizeof(int)的int型数组  
  
  
int(\*b3) \[30\] \[20\]; //三级指针――>指向三维数组的指针；  
  
  
4.数组的数组名具备一些指针的用法，近似于指针，  
  
  
例如：int array\[12\]\[31\];//数组的嵌套定义，array是一个含有12个数组类型元素的数  
  
  
组，其中的每一个  
  
  
元素是一个int数组，array的类型是int\[12\]\[31\]，其指向的类型是int\[31\]，可以理解为  
  
  
array是指向数组  
  
  
的指针。  
  
  
array\[1\]是一个含有31个int型元素的数组，它的类型是int\[31\]，它指向的类型是int；  
  
  
int I;  
  
I = array\[4\]\[7\] 等同于 I = \*(array\[4\]+7) 等同于 I = \*(\*(array +4)+7)  
  
  
int \*p; int \*\*q; int (\*ptr1)\[31\]; int (\*ptr2)\[41\];  
  
  
p = array\[2\];//正确，p指向数组array\[2\]中下标为0的元素  
  
  
p = array; // 错误，array是二维数组，其类型为“数组的数组”，类型不匹配  
  
  
q = array; //错误，array不是指向指针的指针  
  
  
ptr1 = array; // 正确，同是指向数组int\[31\]的指针。  
  
  
ptr2 = array;//错误，array是指向int\[31\]的指针，ptr2是指向int\[41\]的指针。  
  
  
例九：  
  
char\*str\[3\]=\{  
  
  
"Hello,thisisasample!",  
  
  
"Hi,goodmorning.",  
  
  
"Helloworld"  
  
\};  
  
  
chars\[80\]；  
  
  
strcpy(s,str\[0\]);//也可写成strcpy(s,\*str);  
  
  
strcpy(s,str\[1\]);//也可写成strcpy(s,\*(str+1));  
  
  
strcpy(s,str\[2\]);//也可写成strcpy(s,\*(str+2));  
  
  
上例中，str是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向  
  
  
一个字符串。把  
  
  
指针数组名str当作一个指针的话，它指向数组的第0号单元，它的类型是char\*\*，  
  
  
指向的类型是  
  
  
char\*。  
  
  
\*str也是一个指针，它的类型是char\*，它所指向的类型是char，它指向的地址是字符  
  
  
串"Hello,thisisasample!"的第一个字符的地址，即'H'的地址。 str+1也是一个指针，它  
  
  
指向数组的第1号  
  
  
单元，它的类型是char\*\*，它指向的类型是char\*。  
  
  
\*(str+1)也是一个指针，它的类型是char\*，它所指向的类型是char，它指向  
  
  
"Hi,goodmorning."的第一  
  
  
个字符'H'，等等。  
  
  
5.下面总结一下数组的数组名的问题。声明了一个数组TYPE array\[n\]，则数组名称  
  
  
array就有了两重含  
  
  
义：第一，它代表整个数组，它的类型是TYPE\[n\]；第二 ，它是一个指针，该指针的  
  
  
类型是TYPE\*，该  
  
  
指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0  
  
  
号单元，该指针自  
  
  
己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是  
  
  
不能修改的，即  
  
  
类似array++的表达式是错误的。  
  
  
在不同的表达式中数组名array可以扮演不同的角色。  
  
  
在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数测出的是整个  
  
  
数组的大小。  
  
  
在表达式\*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的  
  
  
值。sizeof  
  
  
(\*array)测出的是数组单元的大小。  
  
  
表达式array+n（其中n=0，1，2，....。）中，array扮演的是指针，故array+n的结果  
  
  
是一个指针，它  
  
  
的类型是TYPE\*，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测  
  
  
出的是指针类型  
  
  
的大小。  
  
  
  
例十：  
  
  
int array\[10\];  
  
  
int(\*ptr)\[10\];  
  
  
ptr=&array;  
  
  
上例中ptr是一个指针，它的类型是int(\*)\[10\]，他指向的类型是int\[10\] ，我们用整个数  
  
  
组的首地址来初  
  
  
始化它。在语句ptr=&array中，array代表数组本身。  
  
  
本节中提到了函数sizeof()，那么我来问一问，sizeof(指针名称)测出的究竟是指针自身类型的大小呢还  
  
  
是指针所指向的类型的大小？答案是前者。例如：  
  
  
int(\*ptr)\[10\];  
  
  
则在32位程序中，有：  
  
  
sizeof(int(\*)\[10\])==4  
  
  
sizeof(int\[10\])==40  
  
  
sizeof(ptr)==4  
  
  
实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小。  
  
6 数组与指针的不同  
  
引例：  
文件1：  
int mango\[100\];  
文件2：  
  
extern int \*mango;  
  
............. //一些引用mango\[i\]的代码  
  
错误：把数组的定义等同于指针的外部声明。  
  
  
  
6．1声明与定义  
  
搞清楚这个问题之前，澄清一些重要概念：  
  
C语言中的对象必须有且只有一个定义，但它可以有多个extern声明。  
  
  
  
概念  
区别  
  
定义  
只能出现在一个地方，确定对象的类型并分配内存，用于创建新的对象。例如：int a\[12\]  
相当于特殊声明，它为对象分配内存。  
  
声明  
可多次出现，描述对对象的类型，用于指代其他地方定义的对象。例如：extern int a\[\]  
相当于普通声明，它所说明的并非自身，而是描述其他地方创建的对象。  
  
  
  
  
由于extern声明不为对象分配内存，所以不必提供关于数组长度的信息。对于多维数组，需要提供除最左边一维之外其他维的长度——给编译器足够的信息产生相应代码。  
  
  
  
6．2输组与指针的访问过程  
  
char a\[9\] = “abckefg”; c = a\[i\];  
  
编译器符号表具有一个地址9980  
  
运行时步骤1：取i的值，将它与9980相加；  
  
运行时步骤2：取地址\[9980+i\]的内容。  
  
Char \*p; c = \*p;  
  
编译器符号表有一个符号p，它的地址是4624  
  
运行时步骤1：取地址4624的内容，就是’5081’；  
  
运行时步骤2：取地址5081的内容。  
  
  
  
6．3定义为指针，但以数组方式引用的过程  
  
char \*p = “abchdefs” c = p\[i\]  
  
编译器符号表有个p，地址为4624  
  
运行时步骤1：取地址4624的内容，即’5081’；  
  
运行时步骤2：取得I的值，并将它与5081相加；  
  
运行时步骤3：取地址\[5081+i\]的内容。  
  
  
  
如果将p声明为指针，那么不管p原来是定义为指针还是数组，都会按照上面的三个步骤操作。  
  
如：char \*p\[10\];  
  
另一个文件中extern char \*p；  
  
当用p\[I\]提取这个声明中的内容时，实际上得到的是一个字符，而编译器却把它当作一个指针……  
  
  
  
  
  
6．4指针和数组的其他区别  
指针  
数组  
  
保存数据地址  
保存数据  
  
间接访问数据，首先取得指针的内容，把它作为地址，然后从这个地址提取数据。如果指针有个下标\[I\]，就把指针的内容加上I作为地址，从中提取数据  
直接访问数据，a\[I\]只是简单的以a+I为地址取的数据。  
  
通常用于动态数据结构  
通常用于存储固定数目且数据类型相同的元素  
  
相关函数为malloc(),free()  
隐式分配和删除  
  
通常指向匿名数据  
自身即为数据名  
  
  
  
  
7 数组与指针相同时  
  
7．1输组与指针的可交换性  
  
数组 声明： extern 如：extern char a\[\]；不能改写成指针形式  
  
定义，如 char a\[10\]；不能改写成指针形式  
  
函数参数，如func(char a\[\])；可随意选择数组或指针  
  
在表达式中使用 如c = a\[I\]；随意选择数组或者指针形式  
  
  
  
规则1：“表达式中的数组名”就是指针。  
  
规则2：C语言把数组下表作为指针偏移量  
  
规则3：作为函数参数的数组名等同于指针  
  
  
  
数组与指针可交换性总结：  
  
1． 用a\[I\]这样的形式对数组进行访问总是被编译器解释为像\*(a+1)这样的指针访问。  
  
2． 指针始终就是指针。它绝不可以改写成数组。可以用下标形式访问指针，一般都是指针作为函数参数时，而且实际传递给函数的是一个数组。  
  
3． 在特定的上下文环境中，也就是它作为函数的参数（也只有这种情况），一个数组的声明可以看作是一个指针。作为函数参数的数组（就是在一个函数调用中）始终会被编译器修改成为之乡第一个元素的指针。  
  
4． 因此，当把一个数组定义为函数参数时，可以选择把它定义为数组，也可定义为指针。不管用那种方法，在函数内部事实上获得的都是一个指针。  
  
5． 在其他所有情况中，定义和声明必须匹配。如果定义了一个数组，在其他文件对他进行声明时也必须把它声明为数组，指针也是如此。  
  
  
  
7．2多维数组  
  
例：  
  
int apricot\[2\]\[3\]\[5\];  
  
int (\*q)\[2\]\[3\]\[5\] = &apricot;  
  
int (\*p)\[3\]\[5\] = apricot;  
  
int (\*r)\[5\] = apricot\[i\];  
  
int \*t = apricot\[I\]\[j\];  
  
int u = apricot\[I\]\[j\]\[k\];  
  
  
  
初始化：  
  
只有字符串常量才可以初始化指针数组  
  
char \* vegetables\[\] = \{ “carrot”,“celery”,“corn”,“cilantro”,“crispy”\};  
  
指针数组不可以由非字符串的类型直接初始化：  
  
int \*weights\[\] = \{ \{1,2,3,4,5\}, \{6,7,8\},\}; //无法编译成功  
  
可以这样做：  
  
int row\_1\[\] = \{1,2,3,4,5,-1\}; //-1是行结束标志。  
  
Int row\_2\[\] = \{6,7,8,-1\};  
  
Int \*weights\[\] = \{Row\_1,Row\_2,\};  
  
  
  
7．3 向函数传递一个一维数组  
  
任何一维数组都可以作为函数实参，形参被改写为指向数组第一个元素的指针，所以需要一个约定来提示数组的长度。一般有两个基本方法：  
  
1， 增加一个额外的参数，表示元素数目(argc就起这个作用)  
  
2， 赋予数组最后一个元素一个特殊的值，提示他是数组的尾部（字符串结尾的‘/0’字符就是起这个作用）。这个特殊值必须不会做为正常的元素值在数组中出现。  
  
  
  
7．4 使用指针向函数传递一个多维数组  
  
C语言无法表达“这个数组的边界在不同的调用中可以变化”这个概念。C语言必须知道数组边界，从而为下标引用产生正确代码。  
  
二维或多维数组无法在C语言中作一般的形参。无法向函数传递一个普通的多维数组。  
  
可以向函数传递预先确定长度的特殊数组。  
  
  
  
方法1，my\_function( int my\_array\[10\]\[20\] );//只能处理10行20列的数组。调用时参数也要匹配  
  
方法2，my\_function( int my\_array\[\]\[20\] );//只能处理20列的数组，调用时参数也要匹配  
  
由于必须提供数组除最左边一维以外的所有维的长度，所以形参只能省略第一个长度。  
  
方法3，my\_function( char \*\*my\_array，…… );  
  
此方法使用前提，必须在调用之前将二维数组改为一个指向向量的指针数组。必须是指针数组，而且必须是指向字符串的指针数组。  
  
  
  
总结：如果多维数组各维的长度是一个完全相同的固定值，那么把它传给一个函数毫无问题。如果情况更一般些，也更常见一些，就是作为函数的参数的数组的长度是任意的，分析如下：  
  
1， 一维数组——没有问题，但须包括一个计数值或者是一个能够标识越界位置的结束符。被调用的函数无法检测数组参数的边界。  
  
2， 二维数组——不能直接传递给寒暑，但可以把矩阵改写为一个一维的指针数组，并使用相同的下标表示法。对于字符串来说，这样是可以的，对于其他类型，需要增加一个计数值或者能够标识越界位置的结束符。同样，他依赖于调用函数和被调用函数之间的约定。  
  
3， 三维或更多维——都无法使用。必须把它分解为几个维数更少的数组。  
  
例1：  
  
int main( int argc, char \*argv\[\] )//由于字符串以’/0’作为结束标志，所以只需要一个argc计数有多少个字符串即可。  
  
例2：  
  
int arr\[2\]\[3\] = \{ \{1,2,3\},\{4,5,6\}\};//将要进行传递的二维数组  
  
做法1：  
  
int \*p\[2\] = \{arr\[0\],arr\[1\]\};将二维数组改造成指针数组，每个指针指向一个一维数组  
  
void fun(int rownum,int colnum,int \*array\[\])；  
  
fun(2,3,p);//传递一个二维数组必须在传递之前将其转化为一个指针数组，传递时还要传递该二维数组的行数和列数。  
  
做法2：  
  
int \*p\[3\] = \{arr\[0\],arr\[1\]，NULL\};将二维数组改造成指针数组，每个指针指向一个一维数组  
  
void fun(in