C语言1-指针的概念、指向普通变量的指针

12
2）指针与一维数组 【例 7.6】 下列程序的运行结果是（ ）。［读 程序写结果，重庆市 2001年第 2次等级考试］
13
14
3）指向字符的指针
15
16
17
18
4）指针与二维数组
19
5）指向一维数组的指针（行指针） 【例 7.18】 对 int（﹡p）［5］；的正确描述 是（ ）。［多选题，重庆市 2003年第 1次等级考 试］ A. p是数组名 B. p是指针变量名 C. p数组中有 5个元素 D .p指向一个包含 5个元素的整型数组 E. p是一个整型数组 答案：B D
22
7）指针数组 当数组的元素类型为指针时，叫做指针数组。 【例 7.21】 下列程序的运行结果是（ ）。 ［读程序写结果，重庆市 2004年第 2 次等级考试］
23
8）指针做函数参数 指针做函数参数的主要目的是利用在函数中， 利用指针去操作主调函数中的变量。 【例 7.22】 下列程序在数组中同时查找最大 值下标和最小值下标，并分别存放在 main函数的 变量 max和 min中，请填空。［读程序写结果，重 庆市 2003年第 2次等级考试］
10
【例 7.3】 由于指针的数据类型实际上是指定 指针所能指向对象的数据类型，所以不同数据类型 的指针变量不能相互赋值。（ ）［判断题，重庆市 2005年第 2次等级考试］ 答案：对 分析：在某些特定情况下，可以在不同数据类 型指针之间通过强制类型转换赋值。
11
【例 7.4】 若有定义：long intj，﹡p；，则操 作 j=（long int）p；是合法操作。（ ）［判断题， 重庆市 2004年第 1次等级考试］ 答案：对 【例 7.5】 在 C 语言中，程序

《C语言程序设计》
计算机科学与技术专业本科
第5章 指针




(一) 教学内容 1. 指针的有关概念； 2. 指针的各种运算 3. 数组元素的指针访问方式 4. 数据存储空间的动态存储分配
第5章 指针
(二) 教学要求 了解：指针的有关概念； 理解：指针的各种运算符的含义，一维和二维 元素的指针访问方式，动态存储分配与释放函 数的含义； 应用：会分析含有指针操作的程序。

第5章 指针 5.3 指针运算 3. 间接访问(*) 操作符*可取指针变量所指单元内容，称为间接引用指针。 *(取内容)和&(取地址)为互逆操作。 #include<stdio.h> void main() { int x=10,y=20; int * xp=&x,*yp=&y; int z=*xp+*yp; printf("%d%d\n",*xp,*yp); *xp+=5; printf("%d%d%d\n",*xp,*yp,z); }


第5章 指针 5.2 指针变量 3. 几点说明 (6)在定义指针变量时，可以用const修饰。 指向常量的指针：在指针定义语句的类型前加const， 表指针指向的数据为常量。 结论：const int * pi=&a;(或int const * pi=&a;)中，*pi 为常量，pi为变量，故*pi不能为左值。

第5章 指针 5.2 指针变量 3. 几点说明 (6)在定义指针变量时，可以用const修饰。 例如： const int a=78; const int b=28; int c=18; const int * pi=&a; //int const * pi=&a; *pi=58; //错误，*pi为常量 pi=&b; *pi=68; //错误，*pi为常量 pi=&c; *pi=88; //错误，*pi为常量 c=98;

4. 结论： 若要使变量的值通过函数调用而发生改变， 则形参必须是指针型，实参为地址量（&<变量名>）
或指针型。
另：全局变量和数组名作为参数也可改变变量的值.
总 结
若要使n个变量的值通过函数调用而发生改变，则
在主调函数中设n个变量，用n个指针变量指向它们。 将这些指针变量作为实参，将其地址传递给被调函
p1 p &a p2 &b p1 &b p2 &a
a 5
b 9
a 5 b 9
}
5,9 9,5
三、指针变量作为函数参数 前面讲过：数值型变量作为函数实参 形参数据值的改变不会影响实参。 但当用地址(指针变量)作参数时，作用为传址， 与数组名类似。 要求：形参、实参均为地址量。
单向 传递
形参，于是，
例：实现10.2 swap(int *p1, int *p2) { int temp; temp=p1; p1=p2；p2= temp; } #include <stdio.h> void main( ) { int a, b;
它代表的是地址＋1个单位
重要概念： 指针变量也有各种类型(如上面所示)，但指针变 量的值只能是整型值。
二、指针变量的引用方式 *指针变量名----表示所指变量的值。 指针变量名----表示所指向变量的指针(地址)。
两个运算符号：
&: 取地址运算符。 &i *: 指针运算符，取其指向的内容（所指变 量的值）。 *p
9,0,10
10,9,0
§10.3 数组与指针
一个变量的地址为该变量的指针。当用一个变 量来存放地址(指针)时，该变量称为指针变量。
一个数组元素相当于一个简单变量。于是，亦 可用一个指针变量来指向数组元素。

分地 表 现 自己 。
（ １ ） 定义指针后， 必须将其初始 化。 可以用做给指针变 量初
始化 的有变量 的地 址， 另一个指针变量 ， 数 组名 ， 函数名等 。 需
语句不起作用。 此时， ｓ ｔ ｒ 手 旨 向的存储区里是什么？ 我们不知道。
要注意的是动态 内存分配 时， 使用之前将其初始化为Ｎ Ｕ Ｌ Ｌ 。 指针在 定义之后， 如果没有 明确 赋值， 那么和其他 变量类 似， 其 内部 的地 址值 是随机 的。 此时指针指 向的空 间中的数据 意义是不可预 测的， 一般 成为野指针。 我们知道在ｃ 语言 中， 指
ｒ ｅ ｅ 或ｄ ｅ ｌ ｅ ｔ ｅ 释放该 内存块 ， 否则 ， 这块 内存 就不能被 量也必 须为指针， 且 应与返 回值的类 型相同。 指针变 量可 以指 的调用ｆ 再 次使用 ， 我们就 说这块 内存泄漏 了。 使 用指针 时， 在赋值 等 向整型变量、 字符 串变 量、 也可以指 向函数 的入 口地址和指针为
函数调用结束后系统会 自动收回 内存 。 的不 同是， 指针数组在指 针的数量 上有所 改变 ， 它 由一 个指针 分配局部动态 变量等 ， 全局数据 区存放的是静态和全局变量 ， 随着程 序的消亡而 自动 演 变到一组同类 指针。
一般 我们 常说的内存 泄漏是指堆 内存 的泄 漏。 堆 （ ２ ） 指针 函数与函数 指针。 指 针函数 是 返回值 为指 针 的函 收收 回内存。 大小任 意的（ 内存块的大小可以 数， 指针 函数 打破 了其它高级 语言中的指针、 数组不能作为返 内存 是指 程序从堆 区中分配的，
写程序还是有很大帮助的。 笔者从几个方面来剖析指针 的本质， 并着重围绕指针的一个重要应用一一动态分配内存来谈谈如何回避常见错

}
10.3.3 指针变量和数组作函数参数 数组名作形参时，接收实参数组的起始地址；
作实参时，将数组的起始地址传递给形参数组。
引入指向数组的指针变量后，数组及指向数 组的指针变量作函数参数时，可有４种等价形式 （本质上是一种，即指针数据作函数参数）：
（1）形参、实参都用数组名 （2）形参、实参都用指针变量 （3）形参用指针变量、实参用数组名 （4）形参用数组名、实参用指针变量
（4）指针变量的++、--与&、*的结合
对于指针变量的++、--与&、*的结合 使用，关键要注意按照运算符的优先级和 结合性进行。
例如： int a=2, *p; p=&a;
•表达式：(*p)++，按运算符的优先级，等价于 a++。其含义为：取出指针变量p所指向的内存单 元的值（即a的值），a的值加1，送回a的内存单 元，a的值变为3，p的值未发生变化，仍然指向 变量a。
程序说明：printf("%s\n",s);语句 通过指向字符串的指针变量s，整体引
用它所指向的字符串的原理：系统首先输出s 指向的第一个字符，然后使s自动加１，使 之指向下一个字符；重复上述过程，直至遇到 字符串结束标志。
main() { char string[ ]=”I love Beijing.”; printf(“%s\n”,string); }
3.数组元素的引用 数组元素的引用，既可用下标法，也可用
指针法。
10.3.2 通过指针引用数组元素 如果有“int a [10],*p=a;” ，则： （1）p+i和a+i都是数组元素a [i]的地址。
（2）*(p+i)和*(a+i)就是数组元素a [i]。 int a [3]； a [0]——*a a [1]——*(a +1) a [2]——*(a +2)

在函数中使用指针参数
03
使用指针参数来访问和修改指针所指向的内容，需要使用“-
>”或“*”运算符。
05
指针的高级应用
指向指针的指针（二级指针）
定义与声明
二级指针是用来存储另一个指 针的地址的指针。在声明时， 需要使用`*`操作符来声明二级
指针。
初始化与使用
通过使用`&`操作符获取一个指 针的地址，并将该地址存储在 二级指针中。然后，可以通过 二级指针来访问和操作原始指
当使用malloc或calloc等函 数动态分配内存后，如果 不再需要该内存，必须使 用free函数释放它。否则， 指针将指向一个无效的内 存地址。
当一个指针在函数中定义 ，但该函数返回后仍然存 在并继续指向无效的内存 地址时，就会产生野指针 。
避免指针越界访问
总结词：指针越界访问是指试图访问数 组之外的内存，这是不安全的，可能会 导致程序崩溃或产生不可预测的结果。
指针与内存分配
通过指针来访问和操作动态分配的内存空间。指针可以 存储动态分配的内存地址，并用于读取和写入该地址中 的数据。
指向结构体的指针
01
定义与声明
指向结构体的指针是指向结构体类型的指针。在声明时，需要使用结
构体类型的名称来声明指向结构体的指针。
02 03
初始化与使用
通过使用`&`操作符获取结构体的地址，并将该地址存储在指向结构 体的指针中。然后，可以通过该指针来访问和操作结构体中的成员变 量。
```
பைடு நூலகம்
指向数组元素的指针
• 指向数组元素的指针是指向数组中某个具体元素的指针。通过将指针指向数组中的某个元素，可以访问该 元素的值。
• 指向数组元素的指针可以通过定义一个指向具体元素的指针来实现。例如，定义一个指向数组中第三个元 素的指针，可以使用以下代码

1) 运算符 ：*
该运算符作用在指针变量上，表示访问指针
变量所指向的数据对象编。辑课件
22
2）作用：
实现对指针所指向的数据对象的间接访问， 包括引用和赋值等基本运算。
例6-6 下面的程序段包含着对指针的间接访问。
int a,b=2,c,*p; …… p=&b; scanf("%d",&a); c=a+*p;
1．指针的赋值
操作指针之前必须赋予确定的值，可以在 定义指针的同时赋予初值，也可以用赋值表达 式对指针变量赋值。
（1）赋空值（NULL）； （2）赋予某个变量的地址。 （3）将一个指针变量的值赋予另一指针变量。
例如：int grade,*p； 编辑课件
16
p=&grade;
2．指针的加减运算
1）运算符：+、-、++、-- 。
--：原地址减去一个地址单位（基类型的实际字 节数）；
例如： int *iptr; …… iptr++；// iptr=iptr+1，向下移动两个字节 iptr--；// iptr=iptr-1，向上移动两个字节
下图给出指针的移动示编意辑课：件
19
3. 取地址运算
1) 运算符：& 2) 作用：获取数据对象的内存地址，如果是结 构数据对象则获取其内存首地址。
重点：
➢ 指针的概念 ➢ 指针运算； ➢ 内存操作函数和动态存储分配。
课堂时数：6—7学时 上机时数：2—3学时 课外上机时数：2—3学时
编辑课件
2
6.1 指针的概念
1. 什么叫指针
一个数据对象的内存地址称为该数据对象 的指针 。

c语言指针的指针用法详解在C语言中，指针是非常重要的一种数据类型。

而指针的指针是指指向指针变量的指针。

它在C语言中也是非常重要的一种数据类型，经常用于动态内存分配和函数传递参数等方面。

下面，我们来详细介绍一下指针的指针在C语言中的用法。

一、指针的基本概念在C语言中，指针是一个变量，用来表示另一个变量的内存地址。

指针变量可以存储任何数据类型的地址，包括整型、字符型、浮点型等。

使用指针可以实现动态内存分配、函数传递参数等功能。

二、指针的指针的概念指针的指针是指指向指针变量的指针。

它的定义方式如下：```int **p;```其中，p是一个指向指针的指针变量，它可以指向一个指针变量的地址。

三、指针的指针的用法指针的指针在C语言中有很多用途，下面列举几个比较常见的用法。

1.动态内存分配在C语言中，可以使用malloc函数动态分配内存，该函数返回的是一个指向分配内存的首地址的指针。

而在一些情况下，需要动态分配二维数组或者指针数组，这时就需要使用指针的指针了。

例如：```int **p;int i,j;p=(int **)malloc(sizeof(int*)*3);//分配3个指向int类型指针的指针变量for(i=0;i<3;i++){p[i]=(int*)malloc(sizeof(int)*4);//分配4个int类型的变量}for(i=0;i<3;i++){for(j=0;j<4;j++){p[i][j]=i*j;//为p[i][j]赋值}}```上述代码中，先使用malloc函数分配3个指向int类型指针的变量，然后再用循环分别为这3个变量分配4个int类型的变量。

最后，再使用嵌套循环为二维数组赋值。

2.函数传递参数在C语言中，函数可以通过指针传递参数。

指针的指针也可以用于函数传递参数，可以使函数返回多个值。

例如：```void fun(int **p){*p=(int*)malloc(sizeof(int)*4);//为指针p分配4个int类型的变量(*p)[0]=10;(*p)[1]=20;(*p)[2]=30;(*p)[3]=40;}int main(){int *p;fun(&p);//传递p的地址printf("%d %d %d %d\n",p[0],p[1],p[2],p[3]);free(p);//释放内存return 0;}```上述代码中，定义了一个指针类型的函数fun，在函数中通过指针的指针为指针p分配4个int类型的变量，并为这4个变量赋值。

3.间接引用指针
间接引用指针时，可获得由该指针变量所指向的变量内容。
例如，int i=10,*ip=&i;
ip
i
cout<<*ip<<endl;
0000:F384 0000:F384 210
运行结果为：10 即指针ip所指向的变量i的内容。
*放在定义过的指针变量之前，称为间接引用操作符； *放在指针变量定义中时，称为指针定义符。 非指针变量不能用间接引用操作符，*只能作用于地址。
例如， double d=1.23,*dp; char c,*cp;
在&和cp*=作&d用; 下，对变量d和dp有如下6种操作： 其d，中d，dpp，=*&d*是cd; ，非*法dp的，；&&d指，dp针&是只d指p能。针指的向地与址其即同二类级型指的针量。 另外，指针除了可指向所有基本类型的变量外，指针也可 指向常量、数组、数组元素、函数、指针以及文件等。
int ii=n1t0;b, a[10]; int *inpt=&*pi;1,//*初p2始; 化为整型变量的地址，但 *ip=p&1=i;&//是b;错误的
注意：p2不=p要1将; “//可in以t *将ip=一&个i;”已与赋“值*i的p=指&i针;”混赋淆给。另一个相同类型的指针 前者是p2定=&义a语[5句];，*是指针定义符，系统为指针变量ip分配一个空间， 并2、用i数的地组址的值地初址始值化；可后用者该是数执组行语的句数，组左名右表两边示类。型例不如匹：配。 指 例3、针如变，ip函n=d*d量t数bodob;up在u的b=b[3使ll6ee].地8[用*d;4d=址]前/p2,/!(;.，*5值;p一)由[定4该]要; 函被数$赋$$以的d$:p一$名$个$字$地来址表值$$$，示$:否$。$$则$例是如很#6某#：危.#8变险量的。 没有被do赋ub值le的s指in针(d变ou量bdlep的x值);是一个随机地址，把6.8赋给内存中的 随机位do置ub，le很(可*p能f)破( 坏); 了另一个变量，甚至修改了栈中的函数返回 地址，pf造=s成in计; 算机死机或进入死循环。

值传递
运行结果：5, 9
27
例 将数从大到小输出 swap(int *p1, int *p2) { int p; p=*p1; *p1=*p2; *p2=p; } main() COPY { int a,b; int *pointer_1,*pointer_2; scanf("%d,%d",&a,&b); pointer_1=&a; pointer_2=&b; if(a<b)swap(pointer_1,pointer_2); printf("\n%d,%d\n",a,b); }
19
初始：
a p
?
3 ：
0x2000
？
执行：*p=a
a
3 ： 3
0x2000
p
?
?
20
初始：
a p
?
3 ：
0x2000
？
执行：p=&a
a
3 ：
0x2000
p
0X2000
21
指针变量作为函数参数
当指针变量作为函数参数时,传递的是变量的地址。读 以下程序： void testpoint(int *p) { int t; t=*p; t++; } void main() { int a=3，* p; p=&a; printf(“a=%d\n”,a); testpoint(p); printf(“a=%d\n”,a); }
22
t
3 ：
0x6000
p
&amp;a
指针算术运算
使用递增/递减运算符（++ 和 --）将指针递增或 内存 递减

c语言中什么是指针指针一般指向一个函数或一个变量。

在使用一个指针时，一个程序既可以直接使用这个指针所储存的内存地址，又可以使用这个地址里储存的函数的值。

在计算机语言中，由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。

因此，将地址形象化的称为“指针”。

意思是通过它能找到以它为地址的内存单元。

1：指针是一个地址，指向的是个类型：我们知道，c语言中的类型有int，char，bool(这个不常用)，一般我们使用int，char就可以满足一般的类型需求的，如果对于变量的长度过大，就是用long ，float，double，关于各个类型使用的的长度问题，可以使用sizeof(int)或者sizeof(long)来查看各个类型，在系统中的小。

而指针就是一个8个字节(64系统)。

2：指针指向的是地址，地址指向的是内容：我们需要一个变量，来存储地址，这个变量的值是地址，但是我们可以通过修改变量的值，来不断的改变地址，但是，我们如果需要改变该个地址的值的话，就需要，对地址的值进行修改，而不改变地址。

int a = 10;int *p ;p = &a;*p =11;a=?这里我们看到，p 是一个变量，我们使用p来存储变量a的地址，这是，我们使用*p对于这个变量进行赋值，那么a的值最后，是多少呢，结果是11，因为我们使用*p赋值，就相当于a=11，赋值效果一样的。

3：指针的指针，是面对于指针的变量：我们说，指针的指针的时候，就有点不清楚了，到底怎么区分指针和指针的指针呢。

char *p;char **pr;pr = &p;我们这样看就清楚了一点，char *(*pr); *pr是一个存储的值为指针的变量，pr就是存储上个变量地址的变量。

整合起来就是，pr是一个存储的值为指针的地址的变量。

这样，我们就基本，对于指针有一个直接的了解了。

退出
指针运算
算术运算 int *p, a[10]; p = a; p++; /*p的值增加多少？*/ 的值增加多少？ 的值增加多少 指针的加减运算是以其指向的 指针的加减运算是以其指向的 类型的字节长度为单位的 类型的字节长度为单位的
6000 6001 6002 6003 6004 6005 6006
swap函数的几种错误形式（3/3） 函数的几种错误形式 3/3）
指针p没有确切地址 指针 没有确切地址 void Swap(int *p1, int *p2) { int *p; /*指针 未初始化*/ /*指针p未初始化*/ 指针p未初始化 *p = *p1; *p1 = *p2; *p2 = *p; }
退出
寻址方式
如何读写内存中的数据？ 如何读写内存中的数据？ 两种寻址方式 直接（寻址）访问 直接（寻址）
通过变量地址直接存取变量内容
0 ┇ 3 6 9 ┇ 3010 2000 变量 i_pointer 变量 i 变量 j 变量 k 内存用户数据区
通过变量的地址访问变量所在的 2000 存储单元
2002 2004
退出
指针运算
赋值运算 指针在使用前一定要赋值 为指针变量赋的值必须是一个地址 main() { int *p; scanf("%d",p); … }
错！ 但TC下不报错 下不报错 VC下报错 下报错
main() { int a,*p=&a; scanf("%d",p); … }
退出
指针与函数
指针既然是数据类型，自然可以做函数参数和返回值 指针既然是数据类型， 的类型 指针做函数参数的经典例子： 指针做函数参数的经典例子：

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注意，在定义多个指针时，每个指针前都要加*号，不能省略。

指针与函数 • 指针作为函数参数 交换变量的值 指针函数：返回值为指针类型 指向函数的指针 定义：（类型 *）指针变量名（）； 赋值：将函数名赋值给函数指针变量。P=max; 调用函数：max(x,y)或(*p)(x,y) 函数指针作为函数参数（可根据情况灵活调用不同函数）
指针与数组 • 指向一维数组元素的指针 指向字符串的指针 • 定义与初始化： char *p；p= “Hello”;或p=数组名； 注意：p指向字符串的首地址，*p=„H‟,不是“Hello” 赋值时，*p=“Hello”是错误的。 输入输出：p指向一定的地址空间才可以输入，否 则scanf(“%s”,p)和gets(p)是错误的。注意scanf和gets 的区别。 若p指向某一字符串，可以这样输出： printf(“%s”,p); 或 puts(p);
指针数组 (数组元素为指针) • 定义形式：类型 *指针变量[数组长度];
结构体与共用体
结构体 • 类型和变量定义： struct 结构体类型名{ 类型名 成员变量名； 类型名 成员变量名； ………… }变量名； 或struct 结构体类型名{ 类型名 成员变量名； 类型名 成员变量名； ………… }； struct 结构体类型名 变量名；
数组元素的使用和结构体变量使用一样
stu[i].name stu[i].age
注意:数组元素不能整体输入输出
指向结构体数组的指针 结构体与函数 • 结构体变量作为函数参数 • 指向结构体变量的指针作为函数参数 • 结构体类型的函数
练习
1、从键盘输入n个数，用选择法按从小到大的顺序排 列并输出，要求用指针实现。 2、
scanf(“%s%s%d”, p->num, p->name, &p->age); scanf(“(“%s%s%d”, stu1.num, , &stu1.age);

scanf（″％ｄ，％ｄ″，＆ａ，＆ｂ）； ｐ1＝＆ａ；ｐ２＝＆ｂ； if（ａ＜ｂ） ｛ｐ＝ｐ１；ｐ１＝ｐ２；ｐ２＝ｐ；｝ printf（″ａ=％ｄ,ｂ=％ｄ\ｎ\ｎ″,ａ,ｂ）； printf（″max=％ｄ,min=％ｄ\ｎ″,*ｐ1,*ｐ2）； ｝
运行情况如下： ５，９↙ ａ＝５，ｂ＝９ ｍａｘ＝９，ｍｉｎ＝５ 当输入ａ＝５，ｂ＝９时，由于ａ＜ｂ， 将ｐ１和ｐ２交换。交换前的情况见图 （ａ），交换后见图（ｂ）。
地址。
10.2.2 怎样引用指针变量
在引用指针变量时，可能有三种情况： ⑴给指针变量赋值。如：
p=&a; ⑵引用指针变量的值。如：
printf(“%o”,p); ⑶引用指针变量指向的变量。
有关的两个运算符： (1) ＆ 取地址运算符。 &a是变量a的地址。 (2) * 指针运算符 （或称“间接访问”运算符），*p
1 2 3 4 5 6 7 10 9 0↙
1 2 3 4 5 6 7 10 9 0
10.3.4 用数组名作函数参数
在第7章中介绍过可以用数组名作函数的参数。 如： void main（）
{iｆ（int arr[]，int ｎ）; int array［１０］； ┇ ｆ（array，１０）； ┇ ｝ void ｆ(int arr［ ］，int ｎ)
{ ┇
}
例10．７ 将数组ａ中ｎ个整数按相反顺序存放
#include <stdio.h> void main（） ｛ void inv（int ｘ［ ］，int ｎ）;
int ｉ，ａ［１０］＝｛３，７，９，１１，０， ６，７，５，４，２｝；
printf（″The original array:＼ｎ″）； for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf （″％ｄ，″，ａ［ｉ］）； printf（″＼ｎ″）； inv （ａ，１０）； printf（″The array has been in verted：\ｎ″）； for（ｉ＝０；ｉ＜１０；ｉ＋＋） printf （″％ｄ，″，ａ［ｉ］）； printf （″＼ｎ″）； ｝

8
10/7/2013
内存地址
内存单元
1000 1001 1002 1003 1004
1004
12
图 一个变量指向另一个变量
9
10/7/2013
1、两个概念：变量指针与指针变量
变量指针：一个变量的地址 指针变量：专门存放变量地址的变量
指针 变量的地址
…...
2000
2001 2002 2003 2004 2005
k的 地址 2005
2004
…...
5
8.7
…...
…...
i
k
float k;
编译或函数调用时为变量分配内存单元 变量是对程序中数据 存储空间的抽象
4
程序中：i = 5; k = 8.7；
…...
10/7/2013
7.1.1 指针的概念
理解变量的地址和变量的值
变量名
00000000H 00000001H
C语言程序设计教学课件
第7章
指针
7.0 目标 理解指针的概念 定义指针变量 掌握对指针的操作 理解指针和数组的楼
存储地址
内存
0
…...
存储 单元
601
501
602 502
2000 2001
50
2002 注意：内存单元的地址与内存单元中的数据是 401 402 两个完全不同的概念。 2003 存储单元有
存放变量的内存 单 元 ,int 型 为 两 个 字节。
6
a
变量的值(a=6)
int a; a = 6;
变量的 地址
变量存储在内存某个单元中； 不同类型变量所占内存空间大小不一定相同； 不同编译环境,同一类型变量占用空间大小可能不同

数据类型 *函数名(形参表) { 函数体; }
例8-13 求最长字符串。
函数的返回值为指针，指针数组作函数参数。
8.5.2 执行函数的指针变量(P207)
P207 自学
8.6 指针应用举例 (P208)
P208 自学
8.7 动态内存管理 (P214)
动态分配存储空间
malloc( )函数 calloc( ) 函数
2. 变量地址示意图
变量 b 的地址:XXXX 变量b 4字节
例: float b; char c;
变量 c 的地址:XXXX 数组 a 的地址:XXXX
变量c 1字节
int a[2];
数组a 8字节
变量的地址示意图
8.1.1 指针和指针变量(P185)
指针
变量的存储地址称为该变量的指针。
指针变量
for (i=0;i<4;i++)
p[i]=&a[i*3]; printf ("%d\n",p[3][2]);
8.4 指针作为函数的参数 (P199)
指针变量 ① 形参是指针变量,对应实参是 变量地址 数组名 指针变量 ② 形参是数组名,对应实参是 变量的地址 数组名
8.4.1 指针作参数示例
例8-10 两数交换。形参为指针变量，实参为变量
char *p="abcd";
读下列程序段,分析输出结果
(1)
char s[]="ABCD";
char *p; for (p=s; p<s+4; p++) printf("%s\n",p);
读下列程序段,分析输出结果