指向多维数组的指针变量
C语言程序设计_谭浩强_第二版_CH10
}
第十章 指针 10.3 数组的指针和指向数组的指针变量 10.3.2 通过指针引用数组元素 例10.5输出数组中的全部元素。 ②通过数组名计算数组中元素的地址，找出元素的值。
main() {
int a[10],i; for(i=0;i<10;i++){scanf(“%d”,&a[i]);} print(“\n”); for(i=0;i<10;i++){printf(“%d”,*(a+i));} print(“\n”);
}
运行结果为： 100,10 100,10
第十章 指针 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用 例10.1 通过指针变量访问整型变量
pointer_1 &a
a 100 *pointer_1
pointer_2 &b
b 10 *pointer_2
第十章 指针 10.2 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用 例10.3 通过指针变量访问整型变量
pointer_1 &a
a 5 *pointer_1
pointer_2 &b
b 9 *pointer_2
第十章 指针 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用 例10.3 通过指针变量访问整型变量
b 5 *pointer_2
&b
第十章 指针 10.2 变量的指针和指向变量的指针变量
10.2.1指针变量的引用 例10.3 通过指针变量访问整型变量
pointer_1 &a
a 9 *pointer_1
二级C语言笔试-174
二级C语言笔试-174(总分：98.00，做题时间：90分钟)一、选择题(总题数：40，分数：70.00)1.若有下面的程序片段：int[12]=0，*p[3]，**pp，i；for(i=0；i＜3；i)p[i]=&a[i*4]；pp=p；则对数组元素的错误引用是（分数：2.00）__________________________________________________________________________________________ 解析：[命题目的] 考查指向数组的指针。
[解题要点] 本题综合考查一维数组和多维数组指针变量的表示方法。
在C语言中，引用数组元素的方法有两种，即下标法和指针法。
下标法如a[i]形式；指针法如*(a+i)或*(p+1)。
其中，a是数组名，p是指向数组的指针变量，其初值p=a。
再如*(*(p+2)+2)是a[2][2]的值，注意语句中指针型数组的书写格式，不能写成“(*数组名)[长度]”，因为这是定义指向含有“长度”个元素的一维数组的指针变量。
例如有定义语句"int a，b，c，c，*p[3]={&a，&b，&c2.下面能正确进行字符串赋值操作的是（分数：2.00）A.chars[5]="ABCDE"；B.char s[5]='A'，'b'，'C'，'D'，'E'；C.char*s；s="ABCDE"；√D.char*s；scanf("%s"，s)；解析：[命题目的] 考查了一维字符数组的定义和初始化。
[解题要点] 选项A)和B)定义的数组空间太小，至少应该为6个字符的长度才可以。
选项D)中的指针s未赋初值，所以指向一个不确定的地址，因而不能用scanf输入数据到这一指针所指向的地址中。
c语言 ●第10章 指针-1
…
19
2.定义时同时赋值
int a[10];
int *p=a; c规定： /* 相当于int *p=&a[0] */
若有 int a[10];
int *p=a; 则 p+1：指向下一个数组元素。
…
p+i：其指向下移i个元素。
20
说明：若有 int a[10]; int *p=a; (1) p+i *(p+i) = &a[i] a[i]= a+i *(a+i) (2)数组的指针变量也可带下标 a[i] ，p[i]， *(a+i)，*(p+i) 是等价的。 (3)a与p的区别：a代表数组a的首地址，是常量。 p=a; p也代表数组a的首地址，是变量。 如：p++; 是正确的，而 a++; 是错误的。 (4)引用数组元素有三种方法： 下标法： a[i]或p[i] 地址法：＊(a+i) 效率低 指针法：＊(p+i) *p++ 效率高
13
讨论： 若将被调函数swap( )改为： swap(int *p1,int *p2) ｛int *p; *p=*p1; *p1=*p2; *p2=*p; /*中间变量是指针变量所指的对象*/ ｝ p无确定的地址(地址是随机的)，可能指向任何单 元，有可能破坏系统(乱放枪)。加上int c;p=&c;就没 有问题了。
3 6 9 …
i j k
2004
3010
2000
i_pointer
3
二.对内存单位的访问 存数—写 取数—读 对内存单位的访问，是通过地址进行的。 如： printf(“%d”,i)； 读 再如：scanf(“%d”,&i); 写 直接访问：按变量的地址直接读写变量的值。 如：k=i+j; (1)从2000开始的内存单元中取出i的值3. (2)从2002开始的内存单元中取出j的值6. (3)相加后，送入2004开始的内存单元。 间接访问：将变量a的地址存入另一变量b中，访问a时，先 找b,取出a的地址，再按此地址访问a。
指向多维数组的指针和指针变量_C语言程序设计基础(第2版)_[共2页]
![指向多维数组的指针和指针变量_C语言程序设计基础(第2版)_[共2页]](https://img.taocdn.com/s3/m/74b07b6e1a37f111f0855bb6.png)
121 printf("通过指针输出数组的元素：\n");for(p=s; p<(s+10); p++) printf("%4d", *p);return 0; }以上两个程序输入数组元素为1～10，输出结果均为：7.3.3 指向多维数组的指针和指针变量指针可以指向一维数组，也可以指向多维数组。
对于多维数组来讲，多维数组的指针是指多维数组的地址，即首地址。
而多维数组的指针变量是指存放多维数组地址的变量。
多维数组与一维数组类似，既可以用下标表示，也可以用指针表示，还可以用下标与指针组合来表示。
为了清楚理解多维数组的各种表示方法，并在程序设计中灵活应用，下面以二维数组为例进行分析，分析的结果也可以推广到一般的多维数组。
例如一个二维数组int a[2][3]。
数组a 是一个2行3列的二维数组，可以想像成一个矩阵。
各个数组元素按行存储，即先存储a[0]行各个元素（a[0][0],a[0][1],a[0][2]），再存储a[1]行各个元素(a[1][0],a[1][1],a[1][2])。
C 语言中，数组的元素允许是系统或自己定义的任何类型，如果将每一行数组元素当作一个整体，那么一个二维数组就可以看成是由一维数组作为数组元素的数组。
在a[2][3]中，这个一维数组中数组元素可以表示为a[0],a[1]，但a[0],a[1] 本身不是数值，是一维数组，数组名是a[0]，a[1]。
由一维数组与指针的概念可知，a 是元素为行数组的一维数组的数组名，那么对数组a 中元素的存取就可以按一维数组进行处理。
就是说a 是元素为行数组的一维数组的首地址，a+i 就是元素为行数组的一维数组的第i 个元素的地址，即：*(a+i) = a[i]。
例如：int a[2][3]={{1,2,3}{4,5,6}};它在内存中的存储与数组的关系表示如图7-10所示。
图7-10 数组元素与数组地址的关系表示所以，a[i]是第i 个行数组的数组名，a[i]+j 就是第i 个行数组中第j 个元素的地址。
C语言中指针引用多维数组的教学实践
素， 而是 代表指 向元 素 ａ １ 】 ｆ［ 的指针 。 ｉ０ 由此可见 ， 不
２为 什 么 指 针 引 用 多 维 数 组 学 生 总 是 难 以理 论一 维还是 多维数 组 。 ． 虽然 公式 含义 不 同 。 但是 其
形式始 终保 持不 变 ．这 就意 味着处 理 复杂 的多 维 对 于指针 引用一 维数组 ．学生 普遍 反 映很容 数组 ， 然可 以采用 处理一 维数 组 的方法 ． 仍 避免 出 易理 解 。 而对 于指 针引用 二维及 以上 的数组 ． 生 错 。 于大多 数复杂 的指针 引用 多维 数组 的形式 。 学 对 却 始终难 以理 解 。 究其原 因， 主要是 多维数 组 的指 都 可 以利 用这个 公式 变换 成简单 的形式 。
了这个 问题 ． 就解决 了 Ｃ语 言教学 的关键 。
１为 什 么 一 定 要 使 用 指 针 ．
点
如 上分 析 ．有 没有一 种方 法可 以让 学生 走 出
让学 生听得 懂 。 记得 牢 ， 的活呢 ？ 用 笔者 指针 是 Ｃ语 言 的魅 力 所在 ． 编程 带来 很 大 这 个怪 圈 ， 给 的便利 。采 用指针 的好处 主要有 ：１ 利 用指针 访 在 实 际教 学 中总结 出“ （） 一个 中心 ． 个 基本 点 ” 两 的 使得 大多 数学生 都能 轻松 的解决 这个 问题 。 问数组 可 以提 高访 问速 度 。实 际上 下标 法访 问数 规 则 ， 组在计 算机 中仍然 要转换 为指 针法 ．所 以直 接采 用指针 法访 问数 组元素 ． 自然加快 了访 问速 度 ， 特 别 是对 大 型数 组 ， 提高 的 速度 更 可 观 ；２ 采用 函 （） 数指 针可 以提 高程序 的效率 ：３ 利 用 指针 变量做 （）
new10指针
例 b 用指针（传引用）方式求变量的立方
mian()调用函数之前
number 5
nPtr
不确定
函数被调用之后和 计算*nPtr立方之前
number *nPtr 5
nPtr
&number
计算完*nPtr立 方之后
number *nPtr 125
nPtr &number
例10.2利用指针，对输入的两个数按大小顺序输出
例10.8(219) 从10个数中找出其中最大值和最小值。
main() { int i,number[10]; printf("Enter 10 datas :\n"); for (i=0;i<10;i++) scanf("%d",&number[i]); max_min_value(number,10); printf("\nmax= %d, min= %d \n",max,main); }
指针变量指向同一个对象（如数组）的不同单元地 址时，才可以进行比较。
地址在前者为小。
p=NULL 表示指针变量为空值（不指向任何变量）。 任何指针变量或地址都可以与NULL作相等或不相等 的比较。 如 if(p==NULL)……
【注意】在指针p指向某个实体的地址之前，不可对*p进行赋值。 否则可能发生意想不到的错误（p随便指向某个单元）。
数组的指针——数组的首地址。 数组元素的指针——数组元素的地址
数组a首地址赋 给指针变量 p
例10.8(219) 从10个数中找出其中最大值和最小值。
int max,min; /*全局变量*/ void max_min_value(int array [ ], int n ) 元 { int *p, *array_end; 素 array_end=array+n; 数组最后一个元素的地 的 个 址 ( &array[ n ] ) 数 max=min=*array; for (p=array+1;p<array_end;p++) if (*p>max) max=*p; else if (*p<min) min=*p; return; }
C语言多维数组与多级指针
C语言多维数组与多级指针多维数组与多级指针也是初学者感觉迷糊的一个地方。
超过二维的数组和超过二级的指针其实并不多用。
如果能弄明白二维数组与二级指针，那二维以上的也不是什么问题了。
所以本节重点讨论二维数组与二级指针。
一、二维数组1、假想中的二维数组布局我们前面讨论过，数组里面可以存任何数据，除了函数。
下面就详细讨论讨论数组里面存数组的情况。
Excel 表，我相信大家都见过。
我们平时就可以把二维数组假想成一个excel表，比如：char a[3][4];2、内存与尺子的对比实际上内存不是表状的，而是线性的。
见过尺子吧？尺子和我们的内存非常相似。
一般尺子上最小刻度为毫米，而内存的最小单位为1 个byte。
平时我们说32 毫米，是指以零开始偏移32 毫米；平时我们说内存地址为0x0000FF00 也是指从内存零地址开始偏移0x0000FF00 个byte。
既然内存是线性的，那二维数组在内存里面肯定也是线性存储的。
实际上其内存布局如下图：以数组下标的方式来访问其中的某个元素：a[i][j]。
编译器总是将二维数组看成是一个一维数组，而一维数组的每一个元素又都是一个数组。
a[3]这个一维数组的三个元素分别为：a[0],a[1],a[2]。
每个元素的大小为sizeof（a[0]）,即sizof(char)*4。
由此可以计算出a[0],a[1],a[2]三个元素的首地址分别为& a[0]，& a[0]+1*sizof(char)*4，& a[0]+ 2*sizof(char)*4。
亦即a[i]的首地址为& a[0]+ i*sizof(char)*4。
这时候再考虑a[i]里面的内容。
就本例而言，a[i]内有4个char 类型的元素，其每个元素的首地址分别为&a[i]，&a[i]+1*sizof(char)，&a[i]+2*sizof(char)&a[i]+3*sizof(char)，即a[i][j]的首地址为&a[i]+j*sizof(char)。
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语言是一种高级编程语言，它可以直接操作内存中的数据。
指针是c语言中一种特殊的变量，它可以存储另一个变量的地址，也就是内存中的位置。
通过指针，我们可以间接地访问或修改内存中的数据，从而实现更高效和灵活的编程。
本文将介绍c语言指针的基本概念、定义和初始化、运算和应用，以及一些常见的错误和注意事项。
希望本文能够帮助你掌握c语言指针的用法，提高你的编程水平。
指针的基本概念指针是一种数据类型，它可以存储一个地址值，也就是内存中某个位置的编号。
每个变量在内存中都有一个唯一的地址，我们可以用指针来记录这个地址，然后通过这个地址来访问或修改变量的值。
例如，假设有一个整型变量a，它的值为10，它在内存中的地址为1000（为了简化，我们假设地址是十进制数）。
我们可以定义一个指向整型的指针p，并把a的地址赋给p，如下所示：int a =10; // 定义一个整型变量a，赋值为10int*p; // 定义一个指向整型的指针pp =&a; // 把a的地址赋给p这里，&a表示取a的地址，也就是1000。
p = &a表示把1000赋给p，也就是让p指向a。
从图中可以看出，p和a是两个不同的变量，它们占用不同的内存空间。
p存储了a的地址，也就是1000。
我们可以通过p 来间接地访问或修改a的值。
指针的定义和初始化指针是一种数据类型，它需要在使用前进行定义和初始化。
定义指针时，需要指定它所指向的变量的类型。
初始化指针时，需要给它赋一个有效的地址值。
定义指针的一般格式为：type *pointer_name;其中，type表示指针所指向的变量的类型，如int、char、float等；pointer_name表示指针的名称，如p、q、ptr等；*表示这是一个指针类型。
例如：int*p; // 定义一个指向整型的指针pchar*q; // 定义一个指向字符型的指针qfloat*ptr; // 定义一个指向浮点型的指针ptr注意，在定义多个指针时，每个指针前都要加*号，不能省略。
第十章 指针指针是C语言中广泛使用的一种数据类型. 运用指针.
int *p; p=1000;
被赋值的指针变量前不能再加“*”说明符，如写为*p=&a 也是 错误的。
3、指针变量的引用
欲穷千里，更上层楼
两个指针运算符： (1)取地址运算符：& (2)取内容运算符：*
例如： &a为变量a的地址，*p为指针变量p所指向的变 量
#include ”stdio.h”
#include “conio.h”
表示对数组元素a[2]赋以值1
C规定p+1指向下一个元素(实际含义为p+1*d,d为一个数组元素 所占字节数）
如果p的初值为&a[0]，则：
p+i和a+i就是a[i]的地址，或者说它们指向a数组的第i元素
*(p+i) 或*(a+i)是p+i或a+i所指向的数组元素，即a[i]。
p a数组
a[0]
p+1,a+1
a[1]
p+i,a+i
*(p+i)
a[i]
p+9,a+9
a[9]
欲穷千里，更上层楼
p,a,&a[0]均指向同一单 元，它们是数组a的首地 址，也是第0 元素a[0]的 地址。
p+1,a+1,&a[1]均指向 第1元素a[1]。类推可知 p+i,a+i,&a[i]指向第i元素 a[i]。
应该说明的p是变量， 而a,&a[i]都是常量。在 编程时应予以注意。
2）在讲述一维数组时候我们曾经提到： 因为： a[i]和*(a+i) 等价！ 所以： a[i]+j= =*(a+i)+j= =&a[i][j]
C语言程序设计-理论-教学大纲
《C语言程序设计》课程教学大纲课程中文名称：C语言程序设计课程英文名称：The C Programming Language课程编号：TS17003课程性质：通识教育课学时：总学时72、理论课学时48、实验课学时24学分：4开课学期：第3学期适用对象：电子科学、应用化学、机械电子、车辆工程、电信工程、地理信息系统等本科专业先修课程：高等数学、大学计算机基础课程简介：《C语言程序设计》是工学、理学类专业的一门重要基础课，通过讲授使学生掌握C语言的基本语法、语句、程序控制结构以及结构化程序设计的基本思想和方法，使学生认识计算机程序设计算法、养成良好的程序设计风格及认识程序设计实践在本课程学习中的重要性，培养学生熟练使用C语言分析和解决实际问题的能力，为学生进一步学习其他专业课程和今后从事软件开发工作打下坚实的基础。
一、教学目标及任务计算机程序设计是当代大学生必备的基本技能，C语言是一种功能完备、使用方便的程序设计语言，学生程序设计能力的培养和提高，也是其计算机应用水平的体现。
《C语言程序设计》是我校理工类非计算机专业学生的通识课，也是全国计算机专业等级考试二级C语言程序设计的重要内容。
本课程的任务是让学生掌握C语言基本知识及程序设计的基本方法，学会运用C语言作为工具，通过程序设计以解决和处理现实世界中尤其是与本专业有关的大量实际问题，着重于学生程序设计能力的培养。
二、学时分配三、教学内容及教学要求第一章 C语言程序设计概述（2学时）教学要求：1．了解C语言发展史、特点、基本词法;2．掌握C语言程序设计的基本结构;3．掌握C程序的上机步骤。
教学重点与难点：重点：C语言程序的基本结构。
难点：计算机程序设计算法。
教学内容：第一节 C语言的历史与特点1．C语言的由来；2．C语言的特点。
第二节 C语言概述1．C语言基本词法；2．计算机常用算法及其表示；3．C语言上机步骤。
本章习题要点：C语言的发展和特点；简单的C程序设计；计算机算法、程序设计语言和程序设计方法。
C语言程序设计》基本知识点
C语言程序设计》基本知识点C语言程序设计》教学基本知识点第一章C语言基本知识1.C源程序的框架尽管各个C源程序的功能千变万化，但框架是不变的，主要有：编译预处理、主函数()、函数n()等，主函数的位置不一定在最前面，可以在程序的中部或后面，主函数的名字固定为main。
2.C语言源程序的书写规则：1)C源程序是由一个主函数和若干个其它函数组成的。
2)函数名后必须有小括号，函数体放在大括号内。
3)C程序必须用小写字母书写。
4)每句的末尾加分号。
5)可以一行多句。
6)可以一句多行。
7)可以在程序的任何位置加注释。
3.语句种类语句是程序的基本成分，程序的执行就是通过一条条语句的执行而得以实现的，根据表现形式及功能的不同，C语言的基本语句可以分为五大类。
1)流程控制语句流程控制语句的功能是控制程序的走向，程序的流程有三种基本结构：顺序结构、分支结构和循环结构，任何复杂的程序都可以由这三种基本结构复合而成。
其中后两种结构要用特定的流程控制语句实现。
2)表达式语句表达式语句的形式是：表达式。
即表达式后跟一分号“；”，分号是语句结束符，是一个语句必不可少的成分。
表达式和表达式语句的区别在于表达式代表的是一个数值，而表达式语句则代表一种动作。
最常见的表达式语句是赋值语句。
3)函数挪用语句函数挪用语句实践上也是一种表达式语句，形式为：在一次函数挪用的小括号后面加上一个分号。
(4)空语句空语句的形式就是一个分号，它不代表任何动作，常常作为一个意义迁移转变点利用。
5)复合语句复合语句从形式上看是多个语句的组合，但在语法意义上它只相当于一个语句，在任何单一语句存在的地方都可以是复合语句。
注意复合语句中最后一个语句末尾的分号不能少。
复合语句右大括号后面没有分号。
4.运算符用来表示数据各种操作的符号称为运算符。
运算符实际上代表了一种类型数据的运算规则。
不同的运算符具有不同的运算规则，其操作的数据类型必须符合该运算符的要求，运算结果的数据类型也是固定的。
五层指针c语言
五层指针c语言
在C语言中，五层指针是指嵌套了五次的指针，也就是指向指向指向指向指向变量的指针。
它可以更灵活地管理内存和数据，从而提高程序的效率和性能。
五层指针可以用于多级指针的嵌套，通过多级指针可以实现对多维数组的访问和操作，减少了数据拷贝的开销，提高了程序的执行效率。
此外，五层指针还可以用于动态内存分配和释放，可以更精确地控制内存的使用，减少了内存碎片的产生，提高了程序的内存利用率和性能。
虽然五层指针可以提高程序的性能和灵活性，但在实际编程中，过多的指针嵌套可能会导致代码的可读性和维护性下降，因此需要在实际开发中根据具体情况进行权衡和选择。
c语言二维数组指针用法
c语言二维数组指针用法在C语言中，我们学习了数组和指针的基本概念和使用方法。
而当数组和指针结合在一起时，就形成了二维数组指针。
本文将详细介绍C语言中二维数组指针的用法。
一、什么是二维数组指针？二维数组指针是指向二维数组的指针变量。
在C语言中，我们可以通过指针访问和操作数组中的元素。
而对于二维数组，我们可以通过指针来操作其行和列，以达到对二维数组的灵活运用。
二、二维数组指针的声明和初始化声明二维数组指针的语法如下：type (*ptr)[col]其中，type表示指针指向的元素类型，ptr为指针变量名，col为二维数组的列数。
初始化一个二维数组指针可以有多种方法，下面是一些常用的示例：1. 直接初始化type arr[row][col];type (*ptr)[col] = arr;2. 初始化为已存在的数组type arr[row][col];type (*ptr)[col];ptr = arr;3. 动态分配内存type (*ptr)[col];ptr = (type (*)[col])malloc(row * col * sizeof(type)); 三、二维数组指针的使用通过二维数组指针，我们可以对数组进行遍历和访问。
下面是一些常用的操作示例：1. 遍历二维数组type (*ptr)[col];for(int i=0; i<row; i++){for(int j=0; j<col; j++){// 访问二维数组元素ptr[i][j] = value;2. 传递二维数组指针给函数type func(type (*ptr)[col]){// 函数内部的操作3. 访问二维数组某一行或某一列type (*ptr)[col];// 访问第i行ptr[i];// 访问第j列for(int i=0; i<row; i++){ptr[i][j];通过本文的介绍，我们了解了C语言中二维数组指针的用法。
C语言指针讲解
float a;
int * pointer_1;
pointer_1=&a;
编辑课件
9
在对指针变量赋值时需要注意两点：
⑴ 指针变量中只能存放地址（指针），不要将一个 整数赋给一个指针变量。
例: * pointer_1＝１００； /* pointer_1是指针 变量,１００是整数，不合法 */
(2) 赋给指针变量的变是量地址不能是任意的类型， 而只能是与指针变量的基类型具有相同类型的变 量的
编辑课件
22
可以用一个指针变量指向一个数组元素。
例如：ｉｎｔ ａ［１０］； (定义ａ为包含１０个整型数据的数组)
ｉｎｔ *ｐ； (定义ｐ为指向整型变量的指针变量)
ｐ＝＆ａ［０］； (把ａ［０］元素的地址赋给指针变量ｐ) 也就是使ｐ指向ａ数组的第０号元素 。
编辑课件
23
编辑课件
24
10.3.2 指针的运算
编辑课件
29
(3) 用指针变量指向数组元素。
#include <stdio.h> void main（） ｛ int ａ［１０］；
int *ｐ，ｉ； for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（″％ｄ″，＆ａ［ｉ］）； printf（″＼ｎ″）； for（ｐ＝ａ；ｐ＜（ａ＋１０）；ｐ＋＋）
printf（″％ｄ ″，*ｐ）； ｝
｛ void exchange（int *ｑ1， int *ｑ2， int *ｑ3）;
int ａ，ｂ，ｃ，*ｐ１，*ｐ２，*ｐ３；
scanf（″%ｄ，%ｄ，%ｄ″，&ａ, &ｂ, &ｃ）；
ｐ１＝＆ａ；ｐ２＝＆ｂ；ｐ３＝＆ｃ；
exchange （ｐ１，ｐ２，ｐ３）；
C程序8
6
指向多维数组的指针有两种： 指向多维数组的指针有两种： 1.指向数组元素的指针变量。 指向数组元素的指针变量。 指向数组元素的指针变量 列的数组成一个一维数组一样， 把 n行 m列的数组成一个一维数组一样， 行 列的数组成一个一维数组一样 用指针变量指向各元素。 用指针变量指向各元素。 a[i][j]数组中，i行j列元素 数组中， 行 列元素 数组中 相对数组首地址的相对位置公式: 相对数组首地址的相对位置公式 i*m+j
14
1.用字符数组 用字符数组: 用字符数组
char str[ ]=“He is a boy”; printf(“%s\n”,str); (1) 数组名 str 代表字符串首地址。 代表字符串首地址。 字符串首地址 (2) str+i→ i号元素的地址。 号元素的地址。 号元素的地址 (3) *(str+i) i号元素的值 号元素的值. 号元素的值
25
10.5 函数的指针 函数的指针
指针变量可以指向整型变量、 指针变量可以指向整型变量、字符 数组，也可指向一个函数。 串、数组，也可指向一个函数。
函数的指针： 函数的指针：指向函数的入口地址 的指针。 的指针。
26
1.函数指针的一般形式： 函数指针的一般形式： 函数指针的一般形式 指针变量名）（） 数据类型 （*指针变量名）（） 指针变量名
9
2. 指向由 个元素组成的一维数组的指针 指向由m个元素组成的一维数组的指针 变量
列数组看成n个由 把n行m列数组看成 个由 个组成的一维数 行 列数组看成 个由m个组成的一维数 组:
指针定义形式: 指针定义形式 int (*p)[m] 如： int (*p)[4]
表示: 是指针 指向一个一维数组，数组有4 是指针， 表示 p是指针，指向一个一维数组，数组有 个元素 。
chap8(指针)
务必记住：*(a+i) 和 a[ i] 是等价的。
如果 a 是一维数组名，则a[ i]代表第 i+1个元素所占的 内存单元。但如果a是二维数组，则a[ i ]代表一维数组名， a[i]本身是不占用内存单元的, 也不存放元素值，而只是 一个地址。 a、a+i、a[ i]、*(a+i)、*(a+i)+j、a[ i]+j都是地址， 而*(a[ i]+j)、*(*(a+i)+j)是二维数组元素a[ i][ j]的值。
二、 字符串指针作函数参数
可以用地址传递的方式，即用字符数组名作 参数或用指向字符串的指针变量作参数，将一个 字符串从一个函数传递到另复制。 用字符数组作参数 void copy_string( from , to ) char from[ ] , to[ ] ; { int i = 0 ; while ( from[i] != „\0‟ ) { to[i] = from[i] ; i + + ; } to[i] = „\0‟ ; 运行结果： } string_a = I am a teacher. string_b = I am a teacher. main( ) {char a[ ] = “I am a teacher.” ; char b[ ] = “you are a student.” ; copy_string( a , b) ; printf( “string_a = %s\nstring_b = %s\n”,a,b); }
形参用字符指针变量 void copy_string(from , to) char *from , *to ; { for ( ; *from != „\0‟; from++; to++) *to = *from ; *to = „\0‟; } main( ) { char *a= “I am a teacher.”; char *b= “you are a student.”; copy_string(a,b); printf( “string_a = %s\nstring_b = %s\n”,a,b) ; }
C语言程序设计（第三版）笔记——谭浩强
第一章 概述1． C语言的特点①语言简洁、紧凑，使用方便、灵活。
共有３２个关键字，９种控制语句。
②运算符丰富，公有３４种运算符。
③数据结构丰富，数据类型有：整型、实型、字符型、数组、指针、结构体、共用体等。
④具有结构化的控制语句（如if…else、while、do…while、switch、for）⑤语法限制不太严格，程序设计自由度大。
⑥允许直接访问物理地址，能进行位（bit）操作，可以直接对硬件操作。
⑦生成目标代码质量高，程序执行效率高。
⑧可移植性好。
2． C语言的用途C虽不擅长科学计算和管理领域，但对操作系统和系统实用程序以及对硬件进行操作方面，C有明显的优势。
现在很多大型应用软件也用Ｃ编写。
Top of Page第二章 数据类型、运算符与表达式1． C的数据类型C的数据类型包括：整型、字符型、实型或浮点型（单精度和双精度）、枚举类型、数组类型、结构体类型、共用体类型、指针类型和空类型。
2．常量与变量常量其值不可改变，符号常量名通常用大写。
变量其值可以改变，变量名只能由字母、数字和下划线组成，且第一个字符必须为字母或下划线。
否则为不合法的变量名。
变量在编译时为其分配相应存储单元。
3．整型数据整型常量的表示方法：十进制不用说了，八进制以0开头，如0123，十六进制以0x开头，如0x1e。
整型变量分为：基本型（int）、短整型（short int）、长整型（long int）和无符号型。
不同机器上各类数据所占内存字节数不同，一般int型为２个字节，long型为4个字节。
4．实型数据实型常量表示形式：十进制形式由数字和小数点组成（必须有小数点），如：0.12、.123、1230.0等。
指数形式如123e3代表123×10的三次方。
实型变量分为单精度（float）和双精度（double）两类。
在一般系统中float型占4字节，7位有效数字，double型占8字节，15~16位有效数字。
5．字符型数据字符变量用单引号括起来，如'a','b'等。
C语言指针
#include <stdio.h>
void main()
{ int a=5,b=3;
int *p;
10
p=&a;
4,4
b=*p+5;
printf(“%d\n”,b);
*p=4;
printf(“%d,%d”,a,*p);
}
三、数组的指针与函数实参
例：编写一函数求一维数组的最大元素及其下 标位置（要求使用指针） 已知：数组首地址p，元素个数n；（作函数参 数） 结果：下标k；（作返回值） int max_array(int *p,int n) 设最大值放在max中，则初始状态为：
max=*p, k=0 如果*(p+i)>max 则max=*(p+i)且k=i
a[i] &a[i][0] *(a+i)
数组元素地址
a+i &a[i]
不要把&a[i]理解为a[i]单元的物理地址,因为 a[i]不是一个变量, &a[i] 和a[i]的值是相等的。但 含意不一样。前者指向行，后者指向列； &a[i]:第i行的首地址 a[i]:第i行0列地址 &a[i]+1:第i+1行的首地址 a[i]+1:第i行1列的地址
指针变量作函数参数
例：编写一个函数实现两个数的交换。
#include<stdio.h>
#include<stdio.h>
void swap(int x,int y) void swap(int *x,int *y)
谭浩强所著的《C程序设计》(第5版,清华大学出版社)善于利用指针【圣才出品】
表 8-1 以变量名和数组名作为函数参数的比较
5．通过指针引用多维数组 （1）多维数组元素的地址 如图 8-5 所示是一个多维数组元素地址示意图。其中 a 代表的是首行（即序号为 0 的行） 的首地址、a＋1 与 a＋2 分别为序号为 1 和 2 的行。
5 / 51
圣才电子书 十万种考研考证电子书、题库视频学习平台
图 8-3 指针变量指向数组元素 2．在引用数组元素时指针的运算
3 / 51
圣才电子书 十万种考研考证电子书、题库视频学习平台
当指针指向数组元素的时候，允许对指针进行加和减的运算。 （1）运算分类 ①加一个整数（用＋或＋＝），如 p＋1。 ②减一个整数（用－或－＝），如 p－1。 ③自加运算，如 p＋＋，＋＋p。 ④自减运算，如 p－－，－－p。 ⑤两个指针相减，如 p1－p2（只有 p1 和 p2 都指向同一数组中的元素时才有意义）。 （2）详细说明 ①指针变量 p＋1 或 p－1 是加上或减去一个数组元素所占用的字节数。 ②如果 p 的初值为&a[0]，则 p＋i 和 a＋i 是指数组元素 a[i]的地址，如图 8-4 所示。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
指向多维数组的指针变量1 多维数组的指针多维数组可以看作是一维数组的延伸，多维数组的内存单元也是连续的内存单元。
换句话说，C语言实际上是把多维数组当成一维数组来处理的。
下面以二维数组为例说明这个概念。
比如，现在有一个int型的二维数组a[3][4]，计算机认为这是一个一维的数组a[3]，数组的三个元素分别是a[0]，a[1]和a[2]。
其中每个元素又是一个一维数组，例如a[0]又是一个包含a[0][0]，a[0][1]，a[0][2]和a[0][3]共4个元素的数组。
如果我们要引用数组元素a[1][2]，可以首先根据下标1找到a[1]，然后在a[1]中找到第3个元素a[1][2]。
假设数组a的起始地址为FF10，对应的内存情况如图：DS:FF10 a[0][0] DS:FF12 a[0][1] DS:FF14 a[0][2] DS:FF16 a[0][3]DS:FF18 a[1][0] DS:FF1A a[1][1] DS:FF1C a[1][2] DS:FF1E a[1][3]DS:FF20 a[2][0] DS:FF22 a[2][1] DS:FF24 a[2][2] DS:FF26 a[2][3]可以看到，二维数组a[3][4]的12个元素在内存中是顺序排列的，因此&a[0][0]是数组第一个元素的地址，为FF10。
a[0][0]，a[0][1]这些数组元素都有具体的内存单元值。
但是，a[0]，a[1]和a[2]这三个数组元素不占用内存单元，它们只是代号（其实就是一个指针常量），是虚拟的东西。
a[0]本身又是一个数组，包含a[0][0]，a[0][1]，a[0][2]和a[0][3]，那么a[0]作为数组名称，按照C语言的语法，a[0]就是数组首地址，也就是数组第一个元素的地址，即a[0][0]的地址FF10。
同理，a[1]是第一个元素a[1][0]的地址，即FF18；a[2]是第一个元素a[2][0]的地址，即FF20。
相对于a[0]，a[1]和a[2]来说，a也是数组的名称，是数组的首地址，即FF10。
a是指向数组首地址的指针，a+1代表什么？a是数组名称，a[0]，a[1]和a[2]是元素，那么a+1就是&a[1]（如果一个一维数组int b[3]，那么b+1是不是&b[1]？），即第二行元素的首地址，指针值为FF18。
同理，a+2就是&a[2]，指针值为FF20。
也可以换个角度去理解。
a是数组首地址，指向二维数组第一行的首地址；计算a+1时，指针a跳过的是整个a[0]，a+1指向二维数组第二行的首地址。
指针a在做加法时，跳过的是一行元素。
a[1]+1代表什么？指针a[1]是一维数组a[1]中第一个元素a[1][0]的地址FF18。
对于一维数组a[1]来说，指针a[1]+1指向了a[1]中第二个元素a[1][1]的地址，即FF1A。
这里指针加法的单位是一列，每次跳过a[1]中的一个数组元素。
*a代表什么？*a也就是*(a+0)，数组第一个元素的值，即a[0]。
前面讲过，a[0]是一个代号，它不是一个具体元素的值，而是内嵌的一维数组a[0]的名字，a[0]本身也是一个指针值。
同理，*(a+1)就是a[1]，*(a+2)就是a[2]。
如果要访问二维数组里第i行第j列的某个元素，可以直接引用a[i-1][j-1]，也可以使用指针的方法。
指向第i行第j列元素的指针为a[i]+j，或者*(a+i)+j，因此，间接用指针引用二维数组里第i行第j列的某个元素，可以表示为*(a[i]+j)或者*(*(a+i)+j)。
特别需要指出的是，a[i]不是一个具体的数组元素，它是一个代号，实际上是一个指针值，代表i+1行里中第一个元素的首地址。
因此&a[i]不能直接理解为a[i]的物理地址，a[i]不是变量，不存在物理地址；&a[i]代表第i+1行的行指针值，和a+i等价。
同样，*a[i]也不能理解为对一个数组元素进行指针运算符操作。
a[i]是一个指针值，是i+1行中第一个元素的首地址，那么*a[i]就是i+1行里中第一个元素的值，即a[i][0]。
总之，二维数组a[i][j]的指针由于出现了虚拟的a[i]这个概念，所以对于初学者很不好理解，请读者仔细消化理解。
下表是上述概念的综合：main(){int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12},i,j;/*打印a*/printf("\na=%X", a);/*打印a+i, &a[i]*/for(i=0;i<3;i++)printf("\na+%d=%X, &a[%d]=%X", i,a+i,i,&a[i]);/*打印a[i], *(a+i)*/for(i=0;i<3;i++)printf("\na[%d]=%X, *(a+%d)=%X", i,a[i],i,*(a+i));/*打印a[i]+j, *(a+i)+j, &a[i][j]*/for(i=0;i<3;i++)for(j=0;j<4;j++)printf("\na[%d]+%d=%X, *(a+%d)+%d=%X, &a[%d][%d]=%X",i,j,a[i]+j, i,j,*(a+i)+j, i,j,&a[i][j]);/*打印**(a+i), *a[i]*/for(i=0;i<3;i++)printf("\n**(a+%d)=%X, *a[%d]=%X", i, **(a+i),i, *a[i]);/*打印*(a[i]+j), *(*(a+i)+j), a[i][j]*/for(i=0;i<3;i++)for(j=0;j<4;j++)printf("\na[%d]+%d=%d, *(a+%d)+%d=%d, &a[%d][%d]=%d",i,j,*(a[i]+j), i,j,*(*(a+i)+j), i,j,a[i][j]);}程序运行的结果为（打印的地址值是动态分配的，不同环境下可能不同；但数组的地址偏移量是相同的）：a=FFBEa+0=FFBE, &a[0]=FFBEa+1=FFC6, &a[1]=FFC6a+2=FFCE, &a[2]=FFCEa[0]=FFBE, *(a+0)=FFBEa[1]=FFC6, *(a+1)=FFC6a[2]=FFCE, *(a+2)=FFCEa[0]+0=FFBE, *(a+0)+0=FFBE, &a[0][0]=FFBEa[0]+1=FFC0, *(a+0)+1=FFC0, &a[0][1]=FFC0a[0]+2=FFC2, *(a+0)+2=FFC2, &a[0][2]=FFC2a[0]+3=FFC4, *(a+0)+3=FFC4, &a[0][3]=FFC4a[1]+0=FFC6, *(a+1)+0=FFC6, &a[1][0]=FFC6a[1]+1=FFC8, *(a+1)+1=FFC8, &a[1][1]=FFC8a[1]+2=FFCA, *(a+1)+2=FFCA, &a[1][2]=FFCAa[1]+3=FFCC, *(a+1)+3=FFCC, &a[1][3]=FFCCa[2]+0=FFCE, *(a+2)+0=FFCE, &a[2][0]=FFCEa[2]+1=FFD0, *(a+2)+1=FFD0, &a[2][1]=FFD0a[2]+2=FFD2, *(a+2)+2=FFD2, &a[2][2]=FFD2a[2]+3=FFD4, *(a+2)+3=FFD4, &a[2][3]=FFD4**(a+0)=1, *a[0]=1**(a+1)=5, *a[1]=5**(a+2)=9, *a[2]=9a[0]+0=1, *(a+0)+0=1, &a[0][0]=1a[0]+1=2, *(a+0)+1=2, &a[0][1]=2a[0]+2=3, *(a+0)+2=3, &a[0][2]=3a[0]+3=4, *(a+0)+3=4, &a[0][3]=4a[1]+0=5, *(a+1)+0=5, &a[1][0]=5a[1]+1=6, *(a+1)+1=6, &a[1][1]=6a[1]+2=7, *(a+1)+2=7, &a[1][2]=7a[1]+3=8, *(a+1)+3=8, &a[1][3]=8a[2]+0=9, *(a+2)+0=9, &a[2][0]=9a[2]+1=10, *(a+2)+1=10, &a[2][1]=10a[2]+2=11, *(a+2)+2=11, &a[2][2]=11a[2]+3=12, *(a+2)+3=12, &a[2][3]=12从输出的结果可以看到，&a[i]和a[i]的输出值都是一样的。
第i+1行的首地址是FFBE，第i+1行、第1列元素的首地址也是FFBE，这并不矛盾，因为二者都是一个指针值。
但是，二者的含义是截然不同的，指针加法的偏移量也是不同的：前者加1指针跳到下一行；后者加1指针跳到下一列。
2 指向多维数组的指针变量可以定义指针变量，指向多维数组及其元素。
下面仍以二维数组为例进行说明。
二维数组在内存中是连续的内存单元，我们可以定义一个指向内存单元起始地址的指针变量，然后依次拨动指针，这样就可以遍历二维数组的所有元素。
例如：main(){float a[2][3]={1.0,2.0,3.0,4.0,5.0,6.0},*p;inti;for(p=*a;p<*a+2*3;p++)printf("\n%f ",*p);}结果输出：1.0000002.0000003.0000004.0000005.0000006.000000在上述例子中，定义了一个指向float型变量的指针变量。
语句p=*a将数组第1行，第1列元素的地址赋给了p，p指向了二维数组第一个元素a[0][0]的地址。
根据p的定义，指针p的加法运算单位正好是二维数组一个元素的长度，因此语句p++使得p每次指向了二维数组的下一个元素，*p对应该元素的值。
根据二维数组在内存中存放的规律，我们也可以用下面的程序找到二维数组元素的值：main(){float a[2][3]={1.0,2.0,3.0,4.0,5.0,6.0},*p;inti,j;printf("Please input i =");scanf("%d", &i);printf("Please input j =");scanf("%d", &j);p=a[0];printf("\na[%d][%d]=%f ",i,j,*(p+i*3+j));}输入下标i和j的值后，程序就会输出a[i][j]的值。