第11章--指针与数组
指针和数组的关系
指针和数组的关系
指针和数组是C语言中非常重要的概念，理解它们对于编写高效程序和避免常见错误
至关重要。
指针和数组的关系可以说是紧密相连的，因为数组名本质上就是一个指针。
在C语言中，数组名表示一个指向该数组第一个元素的指针，也就是数组的起始地址。
因此，如果我们定义一个数组a，那么&a和a是等价的，都表示数组第一个元素的地址。
例如，定义一个整型数组a：
int a[5] = {1, 2, 3, 4, 5};
我们可以通过数组名a访问数组中的元素。
例如，a[0]表示数组中的第一个元素，即1。
在C语言中，数组名本身是一个常量，即不能对其进行修改。
但是，我们可以使用指
针来访问数组中的元素，这就需要对指针进行加减运算来实现。
我们可以定义一个指向数组a的指针p，然后通过指针访问数组中的元素。
例如，*p
表示指针p所指向的数组的第一个元素，即1。
我们可以通过p++将指针p指向数组中的下一个元素，例如*p++表示指向数组中的第二个元素，即2。
因此，数组名和指针在C语言中是紧密相关的，数组名本质上就是一个指向数组第一
个元素的指针。
我们可以通过指针访问数组中的元素，并通过加减运算实现对数组的遍
历。
在实际编程中，使用指针可以提高程序的效率和灵活性。
使用指针可以避免对数组名
的重复引用，从而减少程序的存储空间和运行时间开销。
但是，指针操作也比较容易出现指针越界、空指针等错误，因此在使用指针时需特别
注意，避免出现不必要的错误。
数组和指针的区别
数组和指针的区别数组和指针是C语言中非常重要的两个概念，它们在编写程序时起着极其重要的作用。
虽然它们在某种程度上非常相似，但它们之间也存在着很多的差异，下面我们就来分析一下它们的区别。
1. 定义方式数组是由一组具有相同类型的数据元素所组成的有序集合，每个元素具有相同的数据类型，可以通过下标在数组中访问对应的元素。
在C中，定义一个数组可以使用以下语句：```int arr[10];```这个语句定义了一个名为arr的整型数组，这个数组有10个元素。
而指针是一个变量，它存放了一个内存地址，这个地址与它存储的数据类型有关。
在C中，定义一个指针可以使用以下语句：```int *p;```这个语句定义了一个名为p的指针，这个指针指向一个整型变量。
2. 内存分配数组在定义时要求需要一定的内存空间来存储数组元素，因此在定义时就已经确定了内存空间的大小，且数组的大小不可改变。
例如，如果定义一个大小为10的数组，则它的大小就是10，无论实际使用时需要存储的元素个数是多少，数组的大小都不会改变。
而指针在定义时只需要分配一个指针变量所需的内存空间，该指针可以在程序运行时动态地分配内存，因此指针所指向的内存空间大小不确定，需要在运行时根据需要动态地分配或释放空间。
3. 访问方式在数组中，可以通过数组的下标来访问数组中具体的元素，下标从0开始，最大下标为数组大小减1。
例如，访问arr数组中的第三个元素可以写成：arr[2]。
而对于指针，可以通过指针变量所指向的地址来访问该地址所对应的值。
例如，访问p指针所指向地址上的整型变量可以写成：*p。
4. 传递方式在函数调用时，数组可以通过值传递或指针传递来传递数组的值。
如果数组作为参数传递给函数时，实际上传递的是该数组的地址，即使数组非常大，也不会导致栈溢出。
而对于指针，只能通过指针传递方式来传递指针变量的值，在函数内部可以通过指针来修改该指针所指向的地址所存储的值，因此指针可以用来传递地址或修改变量的值。
用指针访问数组的方法
用指针访问数组的方法一、指针与数组的关系。
1.1 指针就像是数组的导航员。
数组在内存里是一块连续的空间，就像住在公寓里的一排房间。
而指针呢，就好比是房间的钥匙或者说是指向这些房间的路标。
它能准确地找到数组里的每个元素，这就跟你拿着钥匙能打开对应的房间门一样。
咱们可以把数组想象成一群小伙伴排着队，指针就可以指出哪个是排头，哪个是排尾，还能找到中间的小伙伴。
1.2 从本质上来说，数组名其实就是一个指针常量。
这就像是一个固定的地址标签，它指向数组的第一个元素。
就好比你家的门牌号，永远指着你家这个“元素”所在的位置。
而且，这个指针常量是不能被修改的，就像你不能随便更改你家的门牌号一样。
二、用指针访问数组元素。
2.1 简单的访问方式。
咱们先定义一个数组，比如说int arr[5] = {1, 2, 3, 4, 5};再定义一个指针，int p = arr; 这里的arr就相当于把数组的首地址给了指针p。
现在如果我们想访问数组的第一个元素，就可以用p，这就像是通过钥匙打开了第一个房间。
如果我们想访问第二个元素呢，那就可以让指针p指向下一个元素，也就是p++，然后再用p来获取这个元素的值。
这就好像你沿着走廊走到下一个房间，再用钥匙打开门看看里面有啥。
2.2 灵活的遍历。
通过指针来遍历数组那是相当方便的。
我们可以写一个简单的循环，像这样：for (int p = arr; p < arr + 5; p++) { printf("%d ", p); }。
这个循环就像是一个小机器人，从数组的开头沿着指针这个“导航路线”一直走到结尾，把每个房间里的东西（元素的值）都展示出来。
这就好比是你沿着一排房间一个一个地查看里面的情况，一个都不落下。
2.3 指针运算的妙处。
指针的运算在访问数组的时候可是很有讲究的。
比如说，p + 2，这里可不是简单的数学加法，它实际上是让指针向后移动两个元素的位置。
这就像是你一下子跳过两个房间，直接到第三个房间的门口。
C语言指针数组介绍定义指针数组输入输出指针数组
C语言指针数组介绍定义指针数组输入输出指针数组C语言中，指针数组是一种特殊的数组类型，其中数组的每个元素都是一个指针。
指针数组允许我们存储和操作一组指针，以及通过指针访问和操作内存中的数据。
本文将介绍指针数组的定义、输入输出和常见用途。
1.定义指针数组定义指针数组的语法如下：```数据类型*数组名[大小];```其中，`数据类型`是指针指向的数据类型，`数组名`是指针数组的名称，`大小`是指针数组的大小（即元素个数）。
举个例子，如果想定义一个包含5个整型指针的指针数组，可以这样做：```int *ptrArray[5];```这个定义表示`ptrArray`是一个包含5个整型指针的数组。
输入指针数组的常见方式是使用循环结构逐个为数组元素赋值，可以使用`scanf`函数进行输入。
```for (int i = 0; i < size; i++)scanf("%d", &ptrArray[i]);```输出指针数组的常见方式是使用循环结构逐个打印数组元素的值，可以使用`printf`函数进行输出。
```for (int i = 0; i < size; i++)printf("%d\n", *ptrArray[i]);```注意这里要使用`*`操作符来访问指针指向的值。
3.指针数组的常见用途指针数组在程序设计中具有广泛的应用。
下面是一些常见的用途：-字符串数组：可以通过定义一个指针数组来存储一组字符串，每个元素都是一个指向字符串的指针。
```char *stringArray[5] = {"Hello", "World", "C", "Language", "Pointer"};```-函数指针数组：可以使用指针数组来存储不同函数的指针，以便在运行时根据需要调用特定的函数。
函数———大连理工大学软件学院蒋光远
2012-9-30
14
C程序设计快速进阶大学教程
11.2.2 指针变量的引用 指针变量说明： 7. 同类型指针变量间可以相互赋值
例11.1 交换指针变量 #include <stdio.h> int main() { int i1=3,i2=4; int *pi1,*pi2,*pi3; pi1=&i1; pi2=&i2;pi3=0; /*交换指针变量*/ pi3=pi1; pi1=pi2; pi2=pi3; printf("i1=%d\ni2=%d\n",i1,i2); printf("*pi1=%d\n*pi2=%d\n",*pi1,*pi2); return 0; }
程序运行结果：
i1=3 i2=4 *pi1=4 *pi2=3
2012-9-30
15
C程序设计快速进阶大学教程
11.2.2 指针变量的引用 指针变量说明： 7. 同类型指针变量间可以相互赋值
例11.1 交换指针变量
起始地址为0012FF70 起始地址为0012FF78 起始地址为0012FF70 0012FF78 占用4字节 (指针变量pi1) 起始地址为0012FF68 00000000 占用4字节 (指针变量pi3) 3 占用4字节 (变量i1) 0012FF74 占用4字节 (指针变量pi1) 起始地址为0012FF68 00000000 占用4字节 (指针变量pi3) 起始地址为0012FF74 4 占用4字节 (变量i2) 起始地址为0012FF78 3 占用4字节 (变量i1)
第11章 指针 本章要点
指针概念 指针与数组 指针与函数 字符串
动态空间管理
2012-9-30
指针指向数组的两种赋值方法
指针指向数组的两种赋值方法指针是C语言中非常重要的概念，它可以让我们更加灵活地操作内存中的数据。
在C语言中，数组也是非常重要的数据结构，它可以让我们更加方便地存储和操作一组数据。
在本文中，我们将介绍两种指针指向数组的赋值方法，分别是指针数组和数组指针。
一、指针数组指针数组是指一个数组，其中的每个元素都是一个指针。
这个指针可以指向任何类型的数据，包括数组。
下面是一个指针数组的定义：```int *arr[10];```这个定义表示一个包含10个元素的数组，每个元素都是一个指向int类型数据的指针。
我们可以通过下标来访问数组中的元素，例如：```arr[0] = (int *)malloc(sizeof(int) * 10);```这个语句表示在arr数组的第一个元素中分配了10个int类型的空间。
我们可以通过指针来访问这个空间中的数据，例如：```*(arr[0] + 1) = 10;```这个语句表示将arr数组的第一个元素中的第二个int类型空间的值设置为10。
我们也可以使用下标来访问这个空间中的数据，例如：```arr[0][1] = 10;```这个语句和上面的语句是等价的。
指针数组的优点是可以方便地存储和操作一组指针，例如我们可以使用一个指针数组来存储一组字符串：```char *strs[3] = {"hello", "world", "c language"};```这个语句表示定义了一个包含3个元素的指针数组，每个元素都是一个指向char类型数据的指针。
我们可以通过下标来访问数组中的元素，例如：```printf("%s\n", strs[0]);```这个语句表示输出strs数组的第一个元素，也就是字符串"hello"。
二、数组指针数组指针是指一个指针，它指向一个数组。
这个数组可以是任何类型的数据，包括指针。
软件技术基础之指针和结构体课件ppt课件
变
从右图可知，指 针变量和一般变量一 指针变量pi 变量地址（指针）
量 地 址
样，仅仅是变量旳内
指
存
向
入
容为变量地址旳变量
变量i
变量值
指
而已。这里变量和指针变量旳类型必须一致。
针 变
量
一般而言，指针变量只能存储某一种数据类型旳 变量旳地址，由此可将指针变量分为：整型指针变量、 实型指针变量和字符型指针变量等等，指针变量旳类 型表白了其指向旳存储单元中存储旳数据旳类型。
另一种引用旳形式： 构 造指针变量名 组员名 定义：struct data * today; today 为指向该构造旳指针
可见，“”和“·”操作符分别使用在用指向构造旳 指针和用构造变量来访问构造中旳数据项（组员）时。
例：构造例程。
结 构 体小结
构造体是C语言中旳一种复杂（构造）类型，它是一种 被命名为一种标识符旳多种变量旳集合。构造旳定义拟定了 构造变量或构造指针旳格式，构造是软件设计中实现数据抽 象旳基础。
3、程序中一旦定义了一种变量，该变量在内存中就将 占用一定旳存储单元。变量占用旳存储单元总是n(n>0) 个连续旳字节，开始字节旳地址，就是变量旳地址也可 称为该存储单元旳首地址。
二、指针旳基本概念：
指针就是变量旳地址。与此相应，在C语言中使
用一类专门旳变量即指针变量来存储变量旳地址。
所以，指针变量是存储地址数据旳变量。
四、指针旳“&”、“*”和赋值运算：
1 、& 取地址运算和 * 引用运算 取地址运算符&旳作用是取变量旳地址。如：
& i 表达求变量 i 旳地址。 引用运算符 * 旳作用是取指针指向变量旳内容。
指针与数组
3．通过一个行指针变量引用二维数组的元素
定义一个由m个元素组成的一维数组的指 针变量的一般形式：
类型标识符 (*指针变量名)[m];
注意：*p两侧的圆括号不可缺少。 例如：假若有语句 int a[2][3], (*p)[3]; p=a;
则：⑴ p是一个指向由3个整型元素组成的一 维数 组的指针变量。
方法ain() { int a[10]={54,65,8,2,3,56,8,21,57,98},i;
for(printf("\n"),i=0;i<10;i++) printf("%4d",*(a+i)); }
方法三：用指针变量指向数组元素
main() { int a[10]={54,65,8,2,3,56,8,21,57,98},*p,i;
⑵ p指向a数组，p+1指向数组a的下一行首地 址，a和p的基类型相同，则a数组中任意元 素a[i][j]还可以如下表示： *(p[i]+j) 、*(*(p+i)+j) 、(*(p+i))[j] 、p[i][j]
例：使用行指针变量访问数组元素。
main() {
float fa[5][10], (*pf)[10]=fa; int i,j; for(i=0; i<5; i++)
C语言程序设计
指针与数组
1.1 一维数组的指针
数组的指针 ：是数组的起始地址。
数组元素的指针 ：是数组元素的地址。 当指针变量指向数组或数组元素时，它就是指 向数组的指针变量。
C规定： ⑴数组名代表数组的首地址（起始地址），
也就是第一个元素的地址。
⑵当指针变量p指向数组时，p+1指向数组 的下一个元素。假设一个整型元素占两 个字节，p+1是使p的地址加2个字节。
数组和指针
● 数组：数组是具有一定顺序关系的若干对象的集合体，组成数组的对象称为该数组的元素。
▲ 每个元素有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语言精华之所在，一个C语言达人怎么可以不会指针呢。
下面店铺给大家介绍C语言指针用法，欢迎阅读!C语言指针用法详解(1)关于指针与数组的存储a、指针和数组在内存中的存储形式数组p[N]创建时，对应着内存中一个数组空间的分配，其地址和容量在数组生命周期内一般不可改变。
数组名p本身是一个常量，即分配数组空间的地址值，这个值在编译时会替换成一个常数，在运行时没有任何内存空间来存储这个值，它和数组长度一起存在于代码中(应该是符号表中)，在链接时已经制定好了;而指针*p创建时，对应内存中这个指针变量的空间分配，至于这个空间内填什么值即这个指针变量的值是多少，要看它在程序中被如何初始化，这也决定了指针指向哪一块内存地址。
b、指针和数组的赋值与初始化根据上文，一般情况下，数组的地址不能修改，内容可以修改;而指针的内容可以修改，指针指向的内容也可以修改，但这之前要为指针初始化。
如：int p[5];p=p+1; 是不允许的而p[0]=1; 是可以的;//int *p;p=p+1; 是允许的p[0]=1; 是不允许的，因为指针没有初始化;//int i;int *p=&i;p[0]=1; 是允许的;对于字符指针还有比较特殊的情况。
如：char * p="abc";p[0]='d'; 是不允许的为什么初始化了的字符指针不能改变其指向的内容呢?这是因为p 指向的是“常量”字符串，字符串"abc"实际是存储在程序的静态存储区的，因此内容不能改变。
这里常量字符串的地址确定在先，将指针指向其在后。
而char p[]="abc";p[0]='d'; 是允许的这是因为，这个初始化实际上是把常量直接赋值给数组，即写到为数组分配的内存空间。
这里数组内存分配在先，赋值在后。
(2)关于一些表达式的含义char *p, **p, ***p;char p[],p[][],p[][][];char *p[],*p[][],**p[],**p[][],*(*p)[],(**p)[],(**p)[][];能清晰地知道以上表达式的含义吗?(知道的去死!)第一组：char *p, **p, ***p;分别为char指针;char*指针，即指向char*类型数据地址的指针;char**指针，即指向char**类型数据的指针;他们都是占4字节空间的指针。
深入CC++中指针和数组的关系
摘要指针和数组是C语言学习中的两个重点和难点问题，程序设计中如何正确理解和使用好指针对数组的访问，本文从数组的本质和编译器实现的角度论述原理，给出了比较全面的阐述。
关键词C语言指针数组指针与数组A Further Discussion on the Relationship between Po-inter and Array in C/C++//Yang LidongAbstract Pointer and array are two important and difficult pro-blems in learning C language,in view of how to properly unde-rstand and make good use of an array of access in programming, this article detailed introduces the principle from the nature of an array and complier.Key words C language;pointer;array;pointer and arrayAuthor's address School of Information,Baoshan College, 678000,Baoshan,Yunnan,China1引言在开发一个实际的应用程序过程中，会经常使用到数组和指针。
如何避免出现使用中的错误，使程序能够顺利地通过编译并得到正确的运行结果，是对编程人员的基本要求。
2指针和数组的的概念2.1指针的概念实体的地址也称指针[1]。
指针不能用一般的变量存储，需要用一种特殊的变量来存储，这种特殊的变量就是指针变量。
我们知道，定义变量必须使用数据类型，定义指针变量使用的就是指针数据类型，如int*、int**、char*、char**、int(*)[4]、int(*)()等。
数组表示法和指针表示法
数组表示法和指针表示法是在编程中常用的两种表示数据结构的方式。
1. 数组表示法：数组是一种线性数据结构，它由相同类型的元素按照一定顺序排列而成。
在数组表示法中，我们可以通过数组下标来访问数组中的元素。
数组的下标通常从0开始，依次递增。
例如，如果有一个整型数组 `arr`，我们可以通过 `arr[0]`、
`arr[1]`、`arr[2]` 等方式来访问数组中的元素。
2. 指针表示法：指针是一种变量，其值为另一个变量的内存地址。
在指针表示法中，我们可以使用指针来访问内存中存储的数据。
通过指针，我们可以获取变量的地址，并且可以通过解引用操作符 `*` 来访问该地址处存储的值。
例如，如果有一个指向整型变量的指针 `ptr`，我们可以通过 `*ptr` 来获取该整型变量的值。
在实际编程中，数组表示法和指针表示法经常结合使用，特别是在涉及数组操作和内存管理的情况下。
指针可以用来遍历数组、访问动态分配的内存以及实现复杂的数据结构，从而提高程序的灵活性和效率。
指针与数组
#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语言数组与指针的定义（例子）
c语⾔数组与指针的定义（例⼦）
对以下变量给出定义：
(1) int a：⼀个整型数；
(2) int * a：⼀个指向整型的指针；
(3) int * * a：⼀个指向指针的指针；
(4) int b[10]：⼀个包含10个整型数的数组；
(5) int * b[10]：⼀个包含10个指针的数组，指针所指向的是整型数；
(6) int ( * b )[10]：⼀个指向包含10个整型数数组的指针；
(7) int ( * c ) (int)：⼀个指向函数的指针，该函数包含⼀个整型参数并返回⼀个整型数，即 int f (int x)；
(8) int ( * (c[10]) ) (int)：⼀个包含10个指针的数组，指针指向⼀个函数，该函数包含⼀个整型参数并返回⼀个整型数；
假如有如下定义：
int a[3][5];
(1) ⽤1种⽅法表⽰a[2][3]的地址： &a[2][3]
(2) ⽤2种⽅法表⽰a[2][0]的地址： &a[2][0] <==> a[2]
(3) ⽤3种⽅法表⽰a[0][0]的地址： &a[0][0] <==> a[0] <==> a。
指针引用数组的方法
指针引用数组的方法指针可以引用数组，这意味着我们可以使用指针来访问和操作数组中的元素。
以下是如何使用指针引用数组的方法：1. 数组名作为指针数组名是一个指向数组第一个元素的指针常量。
因此，我们可以使用数组名来获取数组的第一个元素。
例如：int arr[]={1,2,3,4,5};int*ptr = arr;// ptr 指向 arr 的第一个元素2. 地址运算符 (&)地址运算符 (&) 返回变量或表达式的地址。
我们可以使用它来获取数组元素的地址，然后将地址赋给指针。
例如：int arr[]={1,2,3,4,5};int*ptr =&arr[2];// ptr 指向 arr 的第三个元素3. 数组下标我们可以使用数组下标来访问数组元素。
通过将数组名与下标一起使用，我们可以获取该特定元素的地址并将其赋给指针。
例如：int arr[]={1,2,3,4,5};int*ptr =&arr[1];// ptr 指向 arr 的第二个元素使用指针访问数组元素一旦我们有了指向数组元素的指针，我们就可以使用指针来访问和操作该元素。
我们可以使用指针解引用运算符 (*) 来获取指针所指向的元素的值。
例如：int arr[]={1,2,3,4,5};int*ptr = arr;printf("%d\n",*ptr);// 输出 1（arr 的第一个元素）遍历数组我们可以使用指针来遍历数组。
我们可以使用指针递增运算符 (++) 或递减运算符(–) 来遍历数组中的元素。
例如：int arr[]={1,2,3,4,5};int*ptr = arr;while(ptr <=&arr[4]){printf("%d\n",*ptr);ptr++;// 递增指针以访问下一个元素}注意事项•指针只能引用数组中已分配的元素。
•避免指针越界，即访问数组之外的元素。
C语言程序设计 实验11.1_指针数组、指针与函数
scanf("%d",&repeat);
getchar();
for(ri=1;ri<=repeat;ri++){
scanf("%s",str);
count=0;
for(i=0;i<7;i++){
if(strcmp(str,date[i])==0){
color[index]=color[i];
color[i]=temp;
}
for(i = 0; i < n; i++)
printf("%s ", color[i]);
printf("\n");
}
2 编程题
/*---程序填空，不要改变与输入输出有关的语句。输入一个正整数repeat (0<repeat<10)，做repeat次下列运算：编写程序，输入一个月份，输出对应的英文名称，要求用指针数组表示12个月的英文名称。若输入月份错误，输出提示信息。输入输出示例：括号内为说明
用字符指针实现函数str_cat(s,t)，将字符串t复制到字符串s的末端，并且返回字符串s的首地址，并编写主程序。
例：(括号内为说明)
输入
abc
def
输出
abcdef
------*/
#include <stdio.h>
#include <string.h>
char *str_cat(char *s,char *t);
void main()
{
char s[80],t[80];
指针数组及指向一维数组的指针讲解
一、指针数组及指向一维数组的指针（数组指针）讲解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个字符串中找出最长的那个串，并将其地址作为函数值返回。
CC++——二维数组与指针、指针数组、数组指针（行指针）、二级指针的用法
CC++——⼆维数组与指针、指针数组、数组指针（⾏指针）、⼆级指针的⽤法1. ⼆维数组和指针要⽤指针处理⼆维数组，⾸先要解决从存储的⾓度对⼆维数组的认识问题。
我们知道，⼀个⼆维数组在计算机中存储时，是按照先⾏后列的顺序依次存储的，当把每⼀⾏看作⼀个整体，即视为⼀个⼤的数组元素时，这个存储的⼆维数组也就变成了⼀个⼀维数组了。
⽽每个⼤数组元素对应⼆维数组的⼀⾏，我们就称之为⾏数组元素，显然每个⾏数组元素都是⼀个⼀维数组下⾯我们讨论指针和⼆维数组元素的对应关系，清楚了⼆者之间的关系，就能⽤指针处理⼆维数组了。
设p是指向⼆维数组a[m][n]的指针变量，则有：int* p=a[0];//此时P是指向⼀维数组的指针。
P++后，p指向 a[0][1]。
如果定义int (*p1)[n];p1=a;p1++后，p1指向a[1][0];则p+j将指向a[0]数组中的元素a[0][j]。
由于a[0]、a[1]┅a[M-1]等各个⾏数组依次连续存储，则对于a数组中的任⼀元素a[i][j]，指针的⼀般形式如下：p+i*N+j 相应的如果⽤p1来表⽰，则为*(p1+i)+j元素a[i][j]相应的指针表⽰为：*( p+i*N+j) 相应的如果⽤p1来表⽰，则为*(*(p1+i)+j)同样，a[i][j]也可使⽤指针下标法表⽰，如下：p[i*N+j]例如，有如下定义：int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};则数组a有3个元素，分别为a[0]、a[1]、a[2]。
⽽每个元素都是⼀个⼀维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。
若有：int *p=a[0];则数组a的元素a[1][2]对应的指针为：p+1*4+2元素a[1][2]也就可以表⽰为：*( p+1*4+2)⽤下标表⽰法，a[1][2]表⽰为：p[1*4+2]特别说明：对上述⼆维数组a，虽然a[0]、a都是数组⾸地址，但⼆者指向的对象不同，a[0]是⼀维数组的名字，它指向的是a[0]数组的⾸元素，对其进⾏“*”运算，得到的是⼀个数组元素值，即a[0]数组⾸元素值，因此，*a[0]与a[0][0]是同⼀个值；⽽a是⼀个⼆维数组的名字，它指向的是它所属元素的⾸元素，它的每⼀个元素都是⼀个⾏数组，因此，它的指针移动单位是“⾏”，所以a+i指向的是第i个⾏数组，即指向a[i]。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1行2列元素a［1］［2］的值
元素值为13
C程序设计
2 . 指向多维数组元素的指针变量 (1) 指向数组元素的指针变量
例11.6 用指向元素的指针变量输出二维数组元素的值
运行结果如下： 1 3 5 7 9 11 13 15 19 21 23
#include <iostream.h> void main（） ｛ int ａ[3][4]＝｛ 1,3,5,7,9,11,13,15,17,19,21,23｝； int *ｐ； for（ｐ＝ａ［０］；ｐ＜ａ［０］＋１２；ｐ＋＋） ｛ｉｆ（（ｐ－ａ［０］）％４＝＝０） putchar(‘\n’); printf(“%d ”,*ｐ)； ｝ ｝
C程序设计
例11.3 将数组ａ中ｎ个整数按相反顺序存放
C程序设计
#include <stdio.h> void main（） ｛ void inv（int ｘ[]，int ｎ）; int ｉ，ａ[10]＝｛３，７，９，１１，０，６，７，５ ，４，２｝； printf(“The original array:\n”); for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf(“%d “,a[i]); putchar(‘\n’)； inv(a,10); printf(″The array has been in verted:\n″); for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf(“%d “,a[i]); putchar(‘\n’); ｝
C程序设计
void inv（int *ｘ，int ｎ） ｛int ｐ，ｍ，temp，*ｉ，*ｊ； ｉ＝ｘ；ｊ＝ｘ＋ｎ－１； for（；ｉ＜j；ｉ＋＋，ｊ－－） ｛ｔemp＝*ｉ；*ｉ＝*ｊ；*ｊ＝temp；｝ return； ｝
C程序设计
例11．5 用选择法对tdio.h> void main（） { void sort（int ｘ[]，int ｎ）; int *ｐ，ｉ，ａ［10］； ｐ＝ａ； for（ｉ＝０；ｉ＜１０；ｉ＋＋） scanf(“%d”,&a[i]); ｐ＝ａ； sort（ｐ，１０）； for（ｐ＝ａ，ｉ＝０；ｉ＜１０；ｉ＋＋） ｛ printf(“%d “,*ｐ); ｐ＋＋； ｝ ｝
C程序设计
例11.2 通过指针变量输出ａ数组的１０个元素。
#include <stdio.h> void main（） ｛ int *ｐ，ｉ，ａ[10]； ｐ＝ａ； for（ｉ＝０；ｉ＜１０；ｉ＋＋ ） scanf(“%d”,p++)； for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ） printf(“%d “,*p); 程序运行情况： ｝
程序运行情况： 1 2 3 4 5 6 7 8 9 0↙ 1 2 3 4 5 6 7 8 9 0 C程序设计
11.1.4
用数组名作函数参数
在第8章中介绍过可以用数组名作函数的参数。 如： void main（） { void f(int arr[]，int ｎ); int array[10]； ┇ f(array,10)； ┇ ｝ void ｆ(int arr[]，int ｎ) { ┇ }
。指针变量既然可以指向变量，当然也可以指向数组元
素（把某一元素的地址放到一个指针变量中）。所谓数 组元素的指针就是数组元素的地址。
C程序设计
可以用一个指针变量指向一个数组元素。
例如：int
a[10]； (定义ａ为包含１０个整型数据的数 组)
int
*p； (定义ｐ为指向整型变量的指针变量)
ｐ＝＆a[0]； (把ａ[0]元素的地址赋给指针变量ｐ)
C程序设计
(3) 用指针变量指向数组元素。 #include <stdio.h> void main（） ｛ int ａ[10]； int *ｐ，ｉ； for（ｉ＝０；ｉ＜１０；ｉ＋＋） scanf(“%d”,&a[i])； for（ｐ＝ａ；ｐ＜（ａ＋１０）；ｐ＋＋） printf(“%d ”,*ｐ)； putchar(‘\n’); ｝
C程序设计
void sort（int ｘ[ ]，int ｎ） ｛ int ｉ，ｊ，ｋ，ｔ； for(i=0;i<n-1;i++){ k=i; for(j=i+1;j<n;j++) if(x[j]>x[k]) k=j; if(k!=i) { t=x[i]; x[I]=x[k]; x[k]=t; } ｝
(4)*（ｐ＋ｉ）或*（ａ＋ｉ）是ｐ＋ｉ或ａ＋ｉ所指向的数组元素，即ａ
［ｉ］。 (5) 如果指针变量p1和p2都指向同一数组，如执行p2-p1，结果是两个地址
之差除以数组元素的长度。
C程序设计
11.1.3 通过指针引用数组元素
引用一个数组元素，可以用： （１） 下标法，如ａ［ｉ］形式； （２） 指针法，如*（ａ＋ｉ）或*（ｐ＋ｉ）。其中ａ是 数组名，ｐ是指向数组元素的指针变量，其初值ｐ＝ａ。
第11章 指针和数组
C程序设计
本章主要内容
11.1 指针和一维数组间的关系
11.2 指针和二维数组间的关系
11.3 返回指针值的函数
11.4 指针数组和多重指针
11.5 动态分配内存空间
C程序设计
11.1 指针与一维数组间的关系
11.1.1 数组元素的指针
一个变量有地址，一个数组包含若干元素，每个数 组元素都在内存中占用存储单元，它们都有相应的地址
C程序设计
表 示 形 式
含义
地 址
a
a[0］, *(a+0), *a a+1，&a［1］
二维数组名，指向一维数组 a[0］，即0行首地址 0行0列元素地址
2000
2000
1行首地址
2008 2008 2012
a［1］,*(a+1) 1行0列元素a[1][0]的地址 a[1]+2, *(a+1)+2, &a[1][2] *(a[1]+2), *(*(a+1)+2), a[1][2] 1行2列元素a[1][2] 的地址
C程序设计
void inv（int *ｘ，int ｎ） /*形参x为指针变量*/ ｛int ｐ，temp，*ｉ，*ｊ； ｉ＝ｘ；ｊ＝ｘ＋ｎ－１； for（；ｉ＜j；ｉ＋＋，ｊ－－） ｛ｔemp＝*ｉ；*ｉ＝*ｊ；*ｊ＝temp；｝ return； ｝
C程序设计
如果有一个实参数组，想在函数中改变此数组中的 元素的值，实参与形参的对应关系有以下４种情况 ：
(3)实参形参都用指针变量。例如： void main（） ｛int ａ［１０］, *p=a; ┇ ｆ（p，１０）； ｝
void ｆ（int *ｘ，int ｎ） { ┇ }
C程序设计
C程序设计
(4) 实参为指针变量，形参为数组名。如：
void main（） ｛ｉｎｔ ａ［１０］,*p=a； ┇ ┇ ｆ（p，１０）； ｝ void ｆ（int x[ ]，int ｎ） {
(1) 形参和实参都用数组名，如： void main（） ｛ int ａ［１０］； … ｆ（ａ，１０）； ｝ void { } ｆ（int ｘ[ ］，int ｎ）
…
C程序设计
C程序设计
(2) 实参用数组名，形参用指针变量。如： void main（） void ｆ（int *ｘ，int ｎ） ｛int ａ［１０］； { … … ｆ（ａ，１０）； } ｝
1 2 3 4 5 6 7 8 9 0↙
22153 234 0 0 30036 25202 11631 8259 8237 28483
显然输出的数值并不是ａ数组中各元素的值 C程序设计
#include <stdio.h> void main（） ｛ int *ｐ，ｉ，ａ[10]； ｐ＝ａ； for（ｉ＝０；ｉ＜１０；ｉ＋＋） scanf(“%d”,p++)； p=a; for（ｉ＝０；ｉ＜１０；ｉ＋＋，ｐ＋＋ ） printf(“%d “,*ｐ); ｝
C程序设计
(2) 通过数组名计算数组元素地址，找出元素的值。 #include <stdio.h> void main（） ｛ int ａ[10]; int ｉ； for（ｉ＝０；ｉ＜１０；ｉ＋＋） scanf(“%d”,&a[i])； for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf(“%d “,*(a+i)); putchar(‘\n’); ｝
例11.1
输出数组中的全部元素
假设有一个ａ数组，整型，有１０个元素。要输出各元素的 值有三种方法：
C程序设计
(1)下标法 #include <stdio.h> void main（） ｛ int a[10]； int ｉ； for（ｉ＝０；ｉ＜１０；ｉ＋＋） scanf(“%d”,&a[i])； for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf(“%d ”,a[i]); putchar(‘\n’); ｝
３，７，９，１１，０，６，７，５，４，２ The array has been inverted： ２，４，５，７，６，０，１１，９，７，３ C程序设计
C程序设计
对刚才的程序可以作一些改动。将函数inv中的 形参ｘ改成指针变量。
#include <iostream.h> void main（） ｛void inv（int *ｘ，int ｎ）; int ｉ，ａ[10]＝｛３，７，９，１１，０，６，７，５ ，４，２｝； printf(″The original array:\n″); for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf(“%d “,a[i]); putchar(‘\n’); inv（ａ，１０）； printf(“The array has been in verted：\n″); for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf(“%d “,a[i]); putchar(‘\n’)； ｝