组。
int * a[10];它里边放了10个int * 型变量,由于它是一个数组,已经在栈区分配了1
0个(int * )的空
间,也就是32位机上是40个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);//传递一个二维数组必须在传递之前将其转化为一个指针数组,传递时还要传递该二维数组的行数和列数