一维数组与指针

合集下载

专题7 数组和指针的应用

例1. 写出结果： main() { int *p1, a[10]={1，2，3，4，5，6，7，8，9，10} ; p1=a; printf(“%d ”,*p1); printf(“%d ”,*p1++); printf(“%d ”, *(p1+3)); printf(“%d ”,*++p1); printf(“%d ”,(*p1)++); printf(“%d ”,*p1--); printf(“%d ”,*p1); } 例2.若有定义语句:double x[5]={1.0,2.0,3.0,4.0,5.0},*p=x;则错误引用x数组元素的是[08年9月] A)*p B)x[5] C)*(p+1) D)*x
[C] D) aa+1
（3）通过指针变量来表示数组中各元素的地址
可以定义一个指针变量来存放数组的指针或数组元素的指针，且指针变量的基类型就是定义数组时的类型 int *p,a[10]; for(p=a,k=0; k<10;k++) p++; 将数据写入数组元素中几种方式：（1）for(p=a,k=0; k<10;k++) { scanf(“%d”,p); p++; } 进一步简化：（2）for(p=a,k=0; k<10;k++) scanf(“%d”,p++); 再进一步简化：（3）for(p=a,p-a<10; p++) scanf(“%d”,p); 以上三种写法是等价的，要掌握，能看懂。
2、通过指针变量来引用一维数组元素当指针变量指向数组中的某个数组元素时，可以通过“*”来访问其所指向变量的数据。

C语言数组参数与指针参数

C语言数组参数与指针参数我们都知道参数分为形参和实参。

形参是指声明或定义函数时的参数，而实参是在调用函数时主调函数传递过来的实际值。

一、一维数组参数1、能否向函数传递一个数组？看例子：void fun(char a[10]){char c = a[3];}intmain(){char b[10] = “abcdefg”;fun(b[10]);return 0;}先看上面的调用，fun(b[10]);将b[10]这个数组传递到fun 函数。

但这样正确吗？b[10]是代表一个数组吗？显然不是，我们知道b[0]代表是数组的一个元素，那b[10]又何尝不是呢？只不过这里数组越界了，这个b[10]并不存在。

但在编译阶段，编译器并不会真正计算b[10]的地址并取值，所以在编译的时候编译器并不认为这样有错误。

虽然没有错误，但是编译器仍然给出了两个警告：warning C4047: 'function' : 'char *' differs in levels of indirection from 'char 'warning C4024: 'fun' : different types for formal and actual parameter 1这是什么意思呢？这两个警告告诉我们，函数参数需要的是一个char*类型的参数，而实际参数为char 类型，不匹配。

虽然编译器没有给出错误，但是这样运行肯定会有问题。

如图：这是一个内存异常，我们分析分析其原因。

其实这里至少有两个严重的错误。

第一：b[10]并不存在，在编译的时候由于没有去实际地址取值，所以没有出错，但是在运行时，将计算b[10]的实际地址，并且取值。

这时候发生越界错误。

第二：编译器的警告已经告诉我们编译器需要的是一个char*类型的参数，而传递过去的是一个char 类型的参数，这时候fun 函数会将传入的char 类型的数据当地址处理，同样会发生错误。

C语言中数组的总结

C语言中数组的总结目录1.数组的定义2.一维数组的创建和初始化3.给数组元素赋值4.数组下标越界5.二维数组6.多维数组7.指针与一维数组8.指针与多维数组9.指针，数组与函数10.变长数组11.以上全部内容数组的定义1.数组:一系列相同数据类型的有序序列。

2.声明数组：int states[50];char code[28];float candy[13]; 等等……通过声明将会告知编译器三个信息：1）数组内含有多少元素2）元素的数据类型3）数组名一维数组的创建和初始化1.数组的初始化：在数组创建时，我们要为数组初始化。

int months[12]={31,28,31,30,31,30,31,31,30,31,30,31};//数组的初始化int months[ ]={ 31,28,31,30,31,30,31,31,30};//初始化时省略方括号中的数字，编译器会根据初始化列表中项数来确定数组的大小。

（本例中数组的大小为9）const int months[12]={31,28,31,30,31,30,31,31,30,31,30,31};//将数组设置为只读，这样程序只能从数组中检索值，不能把新值写入数组。

（一旦声明为const，便不能再给他赋值）以花括号括起来，用逗号分隔数组元素来初始化数组，逗号和值之间可以使用空格。

C const 与C++ const区别一：c++允许在声明数组时使用const整数变量，而c不允许。

区别二：const定义的变量未初始化时，c会使用一个变量地址上的随机的值，c++会报错未初始化的const 'y'。

区别三：const int y；const int *p2 =&y;int * p1;p1 = p2;//c++不允许这么做（从'const int*'到'int*' [- fper]的无效转换），c 会给出一个警告（赋值从指针目标类型中丢弃“const”限定符）1)失败的初始化数组a）未初始化数组：数组元素和未初始化的普通变量一样，编译器使用的值是内存地址上现有的值，使得数组储存的都是垃圾值。

[工学]《C语言程序设计》第5章___数组、字符串、指针

5.2.2 一维数组的初始化
1、数组声明时初始化在编译阶段进行的。这样将减少运行时间，提高效率。数组初始化的一般形式为：类型符数组名[常量表达式]={值,值…值}；例如： int a[10]={ 0,1,2,3,4,5,6,7,8,9 }; 相当于a[0]=0; a[1]=1;... a[9]=9;
…
a[9]
#include <stdio.h> 声明有10个元素 void main() 的一维数组a {int n,i; float s=0, ave, a[10]; a[0] a[1] … a[9] for(i=0;i<10;i++) a[i] { scanf("%f",&a[i]); a[i] s=s+a[i]; } ave=s/10; for(i=0;i<10;i++) a[i] a[i] if (a[i]>ave) printf("%f ",a[i]); }
说明： ① int a[10]={0,1,2,3,4};
给前5个元素赋值，其余赋0值不能给数组整体赋值，改成{1} 静态存储类型，初值为0 可以省略数组元素个数。初值的个数不能超过元素个数
② int a[10]=1;
③ static int a[3]; ④ int a[ ]={1,2,3,4,5}; ⑤ int a[5]={1,2,3,4,5,1 };
代码： for(i=0; i<N-1; i<5; i++) { p=i; for(j=i+1; i<N; j<6; j++) if(a[j]<a[p]) p=j; t=a[i]; a[i]=a[p]; a[p]=t; } 5-5.c

数组与指针

此外，还可通过算术元运算对指针进行移动，此外，还可通过算术元运算对指针进行移动，来达到引用其他数组元素的目的。其他数组元素的目的。 a[0] p p &a[0] *p a[0] a[1] p+1 p+1 &a[1] *(p+1) a[1] a[2] P+2 p+2 &a[2] *(p+2) a[2] a[3] P+3 p+3 &a[3] *(p+3) a[3] a[4] p+4 p+4 &a[4] *(p+4) a[4]
a[0] a[1] a[2] a[3] a[4]
a
a a+1 a+2 a+3 a+4
a a+1 a+2 a+3 a+4
&a[0] &a[1] &a[2] &a[3] &a[4]
*a *(a+1) *(a+2) *(a+3) *(a+4)
a[0] a[1] a[2] a[3] a[4]
例3: main() { int a[5],*p,i; for(i=0;i<5;i++) scanf(“%d”,a+i); for(i=0;i<5;i++) printf(“%d”,*(a+i)); }
a[1] a[1][0] a[1][1] a[1][2]
此处，的值与的值与a[0]的值相同，但是基类型不同。a是二级的值相同，此处，a的值与的值相同但是基类型不同。是二级指针，是一级指针。指针，a[0]是一级指针。是一级指针 a &a[0][0] a[0] 因此，以下赋值语句是错误的：因此，以下赋值语句是错误的：p=a; a &a[0] a+1 &a[1] a+i &a[i] *(a+i) a[i]

指针和一维数组经典题目

指针和一维数组经典题目
下面是一些经典的指针和一维数组题目：
1. 求一个一维数组的和、平均值、最大值、最小值。

2. 将一个一维数组元素逆序存放。

3. 合并两个有序的一维数组为一个新的有序数组。

4. 将一个一维数组中的奇数和偶数分别放在两个新的一维数组中。

5. 给定一个一维数组和一个目标值，判断目标值是否存在于数组中。

6. 给定一个一维数组和一个目标值，查找目标值在数组中的索引。

7. 统计一个一维数组中0的个数。

8. 对一个一维数组进行冒泡排序或选择排序。

9. 将一个一维数组循环右移k位。

10. 判断一个一维数组是否为回文数组。

这些题目可以帮助您巩固指针和一维数组的基本操作，同时也可以提高您的编程能力。

C++程序设计教程-第4章数组和指针-106

可以将一个指针变量指向同类型数组的首地址，这样就可以通过对该指针变量访问数组元素。
4.2
对一维数组而言，数组名和指针有许多相通的地方，归纳如下：
(1) 数组名a表示数组的起始地址。可以利用a+i表示的第i+1个元素的地址，即&a[i];
(2) 将指针变量pInt指向数组a的起始地址的方法有两种，即pInt=a或pInt=&a[0];
(2) 第二种方法是通过强制类型转换用一个整型常数直接初始化指针类型的变量。这种方法必须在清楚目前存储空间那些“空闲 ”的前提下才能使用，否则在程序运行过程中将会出现致命错误。
4.2
指针变量的值始终是一个地址，它是一个无符号整型数据。
指针变量所指向的数据的类型与指针的类型一致，它的值可以用如下的方法获得：
*<指针变量>
这里的运算符“*”称为取内容运算符。该
运算符的运算结果为作为其操作数的指针变量所指向的数据的值。
4.2
二、指针变量的操作 1、指针变量的赋值运算 (1) 将一个变量的地址直接赋给同类型的指针变量。
(2)同类型的指针之间可以互相赋值，此时这两个指针指向同一个内存单元。
(3)不同类型的指针变量之间可以通过类型强制转换互相赋值。但这样的赋值通常没有价值。
用的空间，由于它存放的是地址，因此该空
间通常与int类型的数据所占用的空间相同，
为4个字节；另一个为该指针变量所指向的数
据所占用的存储空间。如图下图所示（以字
符型指针ptrch1为例）：
ptrch1:
20001
ptrch1所指向的数据:
地址为20001
4.2
指针变量的初始化方法有两种:

c语言5

5.1.3 与指针有关的运算
例5-2 分析下列程序的输出结果。
#include <stdio.h> void main( ) { char a[5]="1234"; char *p; p=a; /*指针变量p指向数组的第一个元素a[0]*/ printf("%d\n",*p); /*输出第一个元素的ASCII值*/ p++; /*指针变量p指向数组的第二个元素a[1]*/ printf("%d\n",*p); /*输出第二个元素的ASCII值*/ }
指针是一种数据类型。指针是指存放数据的内存地址。程序中定义的变量、数组都要分配内存空间，通过这些空间的地址可以访问存储在其中的数据，也就是引用变量或数组元素。可以看出，指针提供了访问数据的另一种方法(通过变量名访问数据是一种)。
5.1.1 指针的概念
“指针”是个地址概念，是指内存储器中存储单元的地址。变量在内存中使用存储空间的起始地址，称为该变量的指针，如图所示。
又：一维数组元素的指针法引用 *(x+i) 与 x[i]等价，所以，二维数组元素的指针引用法形式为： *(*(x+i)+j) 例5-5 使用指针的方法，输出二维数组的元素。 void main() { int x[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; int i,j; for(i=0;i<3;i++) { for(j=0;j<4;j++) printf("%5d",*(*(x+i)+j)); printf("\n"); } }
5.1.3 与指针有关的运算

数组和指针

● 数组：数组是具有一定顺序关系的若干对象的集合体，组成数组的对象称为该数组的元素。

▲ 每个元素有n个下标的数组称为n维数组。

▲ a［100］：下标从0开始，到99止，不能为100。

▲ a［i］［j］：i为行标，j为下标。

● 数组的声明：数组类型数组名［表达式1］［表达式2］……● 数组的使用：数组类型数组名［表达式1］［表达式2］……● 数组的存储：数组元素在内存中是顺序、连续存储的。

● 数组的初始化：就是在声明数组时给部分或全部元素赋初值。

▲ int a[3]={1,2,3}; 等价于 int[]{1,2,3};▲ int a[5]={1,2,3}; //部分初始化，必须连续，不能间隔赋初值▲ int a[2][3]={1,2,3,4,5,6}; 等价于 int a[][3]={1,2,3,4,5,6} //给出全部的初值时，行标可省▲ int a[2][3]={{1,2},{3,4},{5,6}};● 数组作为函数参数▲ 使用数组名传递数据时，传递的是地址▲ 使用数组名做函数的参数，则实参和形参都应该是数组名，且类型要相同▲ 对形参数组的修改，也就是对实参数组的修改▲ int ss(int a[][4],int bb) 调用：ss(b,x); //b是数组，x传递的是第一维的维数● 对象数组▲ 声明：类名数组名[下标表达式]▲ 引用：数组名[下标].成员名▲ 当一个数组中的元素对象被删除时，系统会调用析构函数来完成扫尾工作。

● 指针：是对地址直接操作的手段。

动态内存分配和管理也离不开指针● 指针类型：用来存放内存单元地址的变量类型，就是指针类型。

● 指针变量的声明：数据类型 *标识符；● 与地址相关的运算——"*"和"&"▲ "*"称为指针运算符（也称解析（dereference））,表示获取指针所指向的变量的值，是一元操作符。

c++函数数组参数传递

c++函数数组参数传递C++中函数有多种参数传递方式，其中包括传递数组类型参数。

数组类型参数传递分为两种：传递一维数组和传递二维数组。

下面分别介绍这两种传递方式。

一、传递一维数组在C++中，一维数组的传递方式有两种：指针传递和数组引用传递。

指针传递是把数组名作为指针变量传递给函数，函数中可以通过指针进行数组元素的操作。

数组引用传递则是直接在函数的参数列表中声明数组类型变量，这样函数中就可以直接对数组进行操作，不需要通过指针间接操作数组元素。

1.指针传递对于一维数组的指针传递方式，函数在定义时需要使用指针类型作为形参，具体语法如下：```void func(int *arr, int len);```int *arr是指向int类型的指针变量，len表示数组的长度。

函数中可以通过下标和指针进行数组元素的操作。

例如：```void func(int *arr, int len){for(int i=0; i<len; i++){cout << arr[i] << " ";}cout << endl;}```在函数调用时，需要使用数组名作为实参传递给函数：sizeof(arr) / sizeof(arr[0])的结果就是数组的长度。

2.数组引用传递sizeof(arr) / sizeof(arr[0])的结果就是二维数组的行数，sizeof(arr[0]) / sizeof(arr[0][0])的结果就是二维数组的列数。

int (&arr)[3][3]表示arr是对一个3行3列的int类型数组的引用。

以上就是C++函数数组参数传递的全部内容，希望对大家有所帮助。

在实际开发中，我们经常需要在函数中传递数组类型参数，来完成各种数据处理操作。

此时，了解不同的数组传递方式，可以帮助我们更好地处理数据，提高程序效率。

值得注意的是，在C++中，数组名并不是指向数组首元素的指针，而是一个常量，它的值是一个地址，指向数组首元素。

【C语言】-指向一维数组元素的指针

【C语⾔】-指向⼀维数组元素的指针本⽂⽬录说明：这个C语⾔专题，是学习iOS开发的前奏。

也为了让有⾯向对象语⾔开发经验的程序员，能够快速上⼿C语⾔。

如果你还没有编程经验，或者对C语⾔、iOS开发不感兴趣，请忽略前⾯我们已经学习了指针，如果指针存储了某个变量的地址，我们就可以说指针指向这个变量。

数组及其数组元素都占有存储空间，都有⾃⼰的地址，因此指针变量可以指向整个数组，也可以指向数组元素。

⼀、⽤指针指向⼀维数组的元素1// 定义⼀个int类型的数组2int a[2];34// 定义⼀个int类型的指针5int *p;67// 让指针指向数组的第0个元素8 p = &a[0];910// 修改所指向元素的值11 *p = 10;1213// 打印第⼀个元素的值14 printf("a[0] = %d", a[0]);输出结果：，说明已经通过指针间接修改了数组元素的值，跟指向⼀个普通int类型变量是⼀样的。

由于数组名代表着数组的⾸地址，即a == &a[0]，因此第8⾏代码等价于：// 让指针指向数组的第0个元素p = a;内存分析图如下，⼀个指针变量占⽤2个字节，⼀个int类型的数组元素占⽤2个字节⼆、⽤指针遍历数组元素1.最普通的遍历⽅式是⽤数组下标来遍历元素1// 定义⼀个int类型的数组2int a[4] = {1, 2, 3, 4};34int i;5for (i = 0; i < 4; i++) {6 printf("a[%d] = %d \n", i, a[i]);7 }输出结果：2.接下来我们⽤指针来遍历数组元素先定义⼀个指针，指向数组的第⼀个元素// 定义⼀个int类型的数组int a[4] = {1, 2, 3, 4};// 定义⼀个int类型的指针，并指向数组的第0个元素int *p = a;p的值是a[0]的地址，因此，现在我们利⽤指针p只能访问数组的第0个元素a[0]，⽤*p就可取出a[0]的值1。

指针与数组

#include <stdio.h>
int main()
{ int a[6],i,s,*p;
printf("Please input data:\n");
for(i=0; i<6; i++ )
scanf("%d", &a[i] );
s=0;
for(p=a; p<a+6; p++) s+=*p ;
printf(“s=%d\n”,s);
8
指针与数组
❖指针运算：
指针类型的数据，除了间接引运算、赋值运算 p 2000
等操作外，当指针指向数组时，指针可以做
加减整数、指针相减及指针比较运算。
▪ 1．指针与整数的加、减运算
• 如果指针p是指向数组中的某个元素，加
p+3 2012
上整数n后，新指针p+n指向后续的第n个
a数组
1 2 3 4 5
a[0] a[1] a[2] a[3]
a[4]
元素。
a[5]
▪ 2．指针相减运算
a[6]
• 两个指向同个数组的同类型指针作相减运
a[7]
算，其绝对值表示它们之间相隔的元素数目。
p+92036
a[8] a[9]
▪ 3．指针之间作关系运算
• 两个相同类型指针可作关系运算比较指针
大小。例8.5程序循环控制是通过 p<a+6
– 行指针a+2，转化为元素指针*(a+2)，指向第3行第一个元素,即 a[2][0]。
– 行指针a+i，转化为元素指针*(a+i)+j，指向第i+1行第j+1一个元素, 即a[i][j]。

计算机二级等级考试C语言关于指针的讲解

如果有：则内存情况如图8-1 如果有：int a=5;则内存情况如图则内存情况如图所示。所示。 •a是存储单元（即变量）的名字，是存储单元（即变量）的名字， • 5是存放在存储单元中的内容，是存放在存储单元中的内容是存放在存储单元中的内容， •存储单元的地址是2000。存储单元的地址是存储单元的地址。
注意：注意：
p++; /* 相当于相当于p=p+1; */ 等价于*(p++) 特殊表达式：特殊表达式：不等价于（*p)++ *p++; 和 *p--; 先取用对象（*p)，然后自加减自加减1 先取用对象（，然后p自加减 ++*p;与 *++p; 完全相同与 --*p;与*--p;完全相同，与完全相同这四种形式都是p先自加减，然后再取用对象这四种形式都是先自加减1，然后再取用对象先自加减
本章考点
指针与指针变量的概念。指针与指针变量的概念。指针变量的运算。指针变量的运算。一维数组的地址、指向一维数组的指针及其应用。一维数组的地址、指向一维数组的指针及其应用。二维数组的地址、指向二维数组的指针及其应用。二维数组的地址、指向二维数组的指针及其应用。指针数组的概念及其应用。指针数组的概念及其应用。用指针表示字符串。用指针表示字符串。指针变量作为函数参数。指针变量作为函数参数。指向指针的指针变量及其应用。指向指针的指针变量及其应用。命令行参数的基本概念。命令行参数的基本概念。
b[i] &b[i][0] 代表第行0列元素的地址代表第i行列元素的地址列元素的地址.
b b+1 b+2 则:b *b *(b+i)

第5章数组与指针

也可以用函数strcpy( )实现：
char amounts[6]=”hello”; char customer[6]; strcpy(customer, amounts); /*可以将amounts中的数据复制给 customer*/
（3）strcat（）——字符串的连接该函数是将一个字符串连接到另一个字符串的后面，得到一个新的字符串。如要将字符串customer连接到字符串amounts的后面，可以采用下列语句：
float temp; for(int i=0;i<29;i++) { for(int j=i+1;j<30;j++) { if (cj[i]<cj[j]) { temp = cj[i]; cj[i] = cj[j]; cj[j] = temp; } } } }
//排序
void display( ) { for(int j = 0;j< 30; ++j) { cout << cj[j]<< endl; } } }; int main( ) { students C1; C1.sortData( ); C1.display( ); }
例如：要记录学生的姓名，该如何定义数组？
分析：由于学生的姓名是属于字符串，所以要定义一个字符串数组，如果每个学生的姓名长度在20个字符以内，则可以定义该数组的长度为21 。
char name[21];
• 5.1.4字符串的主要操作
1.字符串的输入和输出字符串的输入和输出与一般变量的输入与输出类似，用cin和cout实现。
第5章数组与指针
本章学习要点
• 1. 掌握一维数组的定义、赋初值以及简单应用； • 2. 掌握一维字符数组和字符串之间的关系，了解字符串的常用操作； • 3. 掌握二维数组的定义、赋初值，了解其应用； • 4. 掌握指针的定义和运算； • 5. 掌握指针与一维数组、字符串的关系； • 6. 掌握动态内存管理的方法； • 7.掌握别名引用和指针引用。

《C++语言程序设计·中国水利水电版》第5章：数组与指针

第5章数组与指针
5.1 数组
5.1.3 字符数组
1. 字符数组的定义 char 数组名[常量表达式]；数组名[常量表达式] char 数组名[常量表达式1][常量表达式2]；数组名[常量表达式1][常量表达式2]；如： char a[10], b[3][4]; 2. 字符数组的初始化 char 数组名[常量表达式] = {‘字符1’, ‘字符2’, …, ‘字符n’}；数组名[常量表达式] {‘字符1’, ‘字符2’, ‘字符n’}；如：char 如：char s[10]={‘c’, ‘ ’, ‘p’, ‘r’, ‘o’, ‘g’, ‘r’, ‘a’, ‘m’}； ‘m’}；
第5章数组与指针
例5.2 用一维数组处理Fibonacci数列的前40项用一维数组处理Fibonacci数列的前40项
#include <iostream.h> #include <iomanip.h> void main() { int i; int f[40]={1,1}; for(i=2; i<40; i++) { f[i] = f[i-1] + f[i-2]; } for(i=0; i<40; i++) { cout << setw(12) << f[i]; if( (i+1)%5 == 0) cout << endl; } cout << endl; }
第5章数组与指针
5.1 数组
5.1.3 字符数组（续二）
第5章数组与指针
例5.1 一维数组的引用
#include <iostream.h> void main() { int i,a[10]; for(i=0; i<10; i++) { a[i] = i*10; } for(i=0; i<10; i++) { cout << a[i] << " "; } cout << endl; } 程序运行结果为：

指针数组及指向一维数组的指针讲解

一、指针数组及指向一维数组的指针（数组指针）讲解1、数组指针（也称行指针）定义 int (*p)[n];()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。

也就是说执行p+1时，p要跨过n个整型数据的长度。

如要将二维数组赋给一指针，应这样赋值：int a[3][4];int (*p)[4];//该语句是定义一个数组指针，指向含4个元素的一维数组。

p=a;//将该二维数组的首地址赋给p，也就是a[0]或&a[0][0] p++;//该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]所以数组指针也称指向一维数组的指针，亦称行指针。

2、指针数组定义 int *p[n];[]优先级高，先与p结合成为一个数组，再由int *说明这是一个整型指针数组，它有n个指针类型的数组元素。

这样赋值是错误的：p=a；只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。

但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。

如要将二维数组赋给一指针数组:int *p[3];int a[3][4];for(i=0;i<3;i++)p[i]=a[i];这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]所以要分别赋值。

这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。

指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。

还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。

比如要表示数组中i行j列一个元素：*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]优先级：()>[]>*例1、下列给定程序中，函数fun()的功能是：从N个字符串中找出最长的那个串，并将其地址作为函数值返回。