C语言第八章地址与指针
C语言 第八章
p
printf(“%d,%d\n”,a,b); printf(“%d,%d\n”,*p1,*p2);}
三、指针变量作为函数参数 作用:将一个变量的地址传送到另一个函数中。 作用:将一个变量的地址传送到另一个函数中。 例1:编写实现两个数的交换的函数 : swap(int *p1, int *p2) *p2) void swap(int *p1, int swap(int x,int y) {{ int temp; 定义为*temp? ? int temp; 定义为 { int temp; temp=*p1; temp=x; temp=*p1; *p1=*p2; x=y; *p1=*p2; y=temp; } *p2=temp; } *p2=temp; } main() main() main() { int a,b,*p1,*p2; { int a,b; { int a,b p1=&a;p2=&b; scanf("%d,%d",&a,&b); scanf(“%d%d”,&a,&b); scanf(“%d%d”,p1,p2); swap(a,b); swap(&a,&b); swap(p1,p2); printf("\n%d,%d\n",a,b); printf("%d, %d\n",a,b); printf("%d, %d\n",a,b); }} }
个字节的问题) 个字节的问题)
二、指针变量的引用 “&”(地址运算符 取变量的存储地址。如:&a求变量 的地址。 地址运算符) 取变量的存储地址。 地址运算符 求变量a的地址 求变量 的地址。 “*” (引用运算符 取指针所指向变量的内容。&与*优先级相同, 引用运算符) 取指针所指向变量的内容。 与 优先级相同 引用运算符 优先级相同, 但按自右至左的结合方向。 但按自右至左的结合方向。 例如: 例如:int i=3,*p; p=&i;
c语言指针详细讲解
c语言指针详细讲解
C 语言中指针是非常强大的概念,它允许程序直接访问内存中的数据。
指针在 C 语言中最初是被用于解决内存分配问题而提出的,随着 C 语言的发展,指针也变得愈发重要。
指针的本质是一个存储变量地址的变量。
在 C 语言中,指针通常用符号&来表示,例如&x 表示的是 x 变量的地址。
指针变量存储的是一个内存地址,当程序读取指针变量时,它会读取该地址中存储的数据。
C 语言中可以使用指针进行高效的内存操作。
例如,当程序需要对一个数组元素进行修改时,可以直接用指针修改该元素的值,而不必修改数组名本身。
另外,指针还可以用于动态分配内存,这是 C 语言中一个重要的特性。
指针的使用方法比较灵活,但也需要小心使用。
如果不小心处理指针,可能会导致未知的错误。
例如,当指针指向的内存空间被释放后,程序试图访问该内存空间时可能会导致未定义的行为。
因此,在C 语言中,指针的使用需要更加谨慎。
C 语言中指针是一个非常重要和强大的概念,掌握指针的使用方法可以让程序员写出更加高效和安全的代码。
C语言 第八章.用户自定义数据类型
u2占2个字节
例:以下程序输出结果是?
union example { struct { int x,y; e.b e.a e.in.x }in; e.in int a; e.in.y int b; }e; void main() { e.a=1;e.b=2; e.in.x=e.a*e.b; e.in.y=e.a+e.b; printf("%d,%d",e.in.x,e.in.y); }
内存低地址 01100001 00001010
字符变量c占1个字节
整型变量i占2个字节 单精度实型变量f占4个字节
u1.i=10;
例:以下程序输出结果是?
union u_type { char c[2]; u1
p
内存高地址 内存低地址 ‘a’ ‘b’ c1 c2 c[1] c[0] u1占2个字节 内存高地址 内存低地址 ‘A’ ‘B’ ‘a’ ‘b’ c1 c2 c[1] c[0]
{"0208103322","lisi",19,'M'},{"0208103323","lili",20,'F'}, {"0208103324","xulin",21,'M'}};
学号(number) 姓名(name) 年龄(age) 性别(sex)
stu[0] stu[1] stu[2] stu[3]
char name[8];
int age; char sex;
定义结构体类 sizeof(stu) 型的同时创建 =? 结构体数组
c语言 指针的指针 用法详解
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个变量赋值。
c语言指针与地址的区别
c语⾔指针与地址的区别
指针由两部分组成,指针的类型和指针的值(也就是变量的地址)。
指针和地址的区别:
地址只是⼀堆⼗六进制的字符,对应着内存条的某段内存,⽽指针本⾝有地址,指针的值也是⼀个地址,指针本⾝还有类型,这与单纯的地址是不同的。
指针和地址的联系:
地址可以强转成⼀个指针,例如:
int a = 1;
//假设a的地址是0x7dfe88
int *p = (int *)0x7dfe88;
附:指针类型的作⽤:
指针的值只是存储了某个变量的⾸地址,但是变量是有类型的,⽐如char是1个字节,int是4个字节,单纯的知道某个变量的⾸地址并⽆法完整的获取整个变量的值,必须知道从⾸地址往下读取多少个字节,指针的类型标明了从⾸地址往下读取多少个字节。
c语言中的指针详解
c语言中的指针详解在C语言中,指针是一种特殊的变量类型,它存储了一个变量的内存地址。
通过指针,我们可以间接访问和修改内存中的数据,这对于一些需要动态分配内存的操作非常有用。
以下是关于C语言指针的一些详细解释:1. 定义指针:使用"*"符号来定义指针变量。
例如,int* ptr; 定义了一个指向整型变量的指针 ptr。
2. 取址操作符(&):取地址操作符(&)用于获取变量的内存地址。
例如,&a 返回变量 a 的地址。
3. 解引用操作符(*):解引用操作符(*)用于访问指针所指向的变量的值。
例如,*ptr 返回指针 ptr 所指向的整型变量的值。
4. 动态内存分配:可以使用相关的库函数(如malloc和calloc)在运行时动态分配内存。
分配的内存可以通过指针来访问和使用,并且在使用完后应该使用free函数将其释放。
5. 空指针:空指针是一个特殊的指针值,表示指针不指向任何有效的内存地址。
可以将指针初始化为NULL来表示空指针。
6. 指针和数组:指针和数组在C语言中有密切的关系。
可以通过指针来访问数组元素,并且可以使用指针进行指针算术运算来遍历数组。
7. 传递指针给函数:可以将指针作为函数参数传递,以便在函数内部修改实际参数的值。
这种传递方式可以避免拷贝大量的数据,提高程序的效率。
8. 指针和字符串:字符串在C语言中实际上是以字符数组的形式表示的。
可以使用指针来访问和操作字符串。
需要注意的是,指针在使用时需要小心,因为不正确的操作可能导致程序崩溃或产生不可预料的结果。
对于初学者来说,理解指针的概念和使用方法可能需要一些时间和练习。
c语言中什么是指针
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是一个存储的值为指针的地址的变量。
这样,我们就基本,对于指针有一个直接的了解了。
C语言程序设计第八章 优化学生成绩分析系统指针.ppt
C语言程序设计
1 指针与字符串(5)
1.2 使用字符串指针变量与字符数组的区别(续) 例2 分析下面程序的运行结果
main() { char *a="I Love China!";
a=a+7; printf(“%s\n",a); }
运行结果: China!
9
项目八 优化学生成绩分析系统-指针
C语言程序设计
int a,b,c;
例sc6an将f(给"%出d的,%程d"序,&修a,改&b为);使用函数指针变量定义
的c=方m式ax(a,b);
c=(*p)(a,b);
printf("a=%d,b=%d,max=%d",a,b,c);
}
max(int x,int y)
{
int z;
if(x>y) z=x;
else z=y;
指针数组,有4个元素,每个元素 都是指向整型变量指针变量
Int (*p)[4];
由4个整型变量组成的数组的指针
21
项目八 优化学生成绩分析系统-指针
#include <stdio.h> ma3in指()针数组 (2)
C语言程序设计
p[0]
11
{ 3.1 指针数组(续)
22
static int
33
a[3][4]={{11,22,33,44},{55,66,77,88},{99,110,1224,4133}};
【项目分析】
为了保存一个班的C语言成绩需要借助于一维数组,通过指针对其数 据进行操作。将本项目分成两部分,首先借助于指针对一维数组进 行访问,然后介绍一种新的排序算法—选择排序。
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字节空间的指针。
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语言程序设计(第八章)
的读写函数。 每次可从文件读出或向文件写入一个字符。
第八章
1.读字符函数fgetc()
fgetc() 函数的功能是从指定的文件中读一个字符,函
数调用的形式为:
字符变量 = fgetc(文件指针);
例如:
ch = fgetc(fp);
的意义是从打开的文件fp中读取一个字符并送入ch中 。
(1)字符读/写函数 :fgetc()/fputc()
(2)字符串读/写函数:fgets()/fputs()
(3)数据块读/写函数:freed/()fwrite()
(4)格式化读/写函数:fscanf()/fprinf()
以上函数原型都在头文件stdio.h中加以声明。
第八章
8.5.1字符读/写函数 :fgetc()/fputc()
关闭文件则断开指针与文件之间的联系,禁止再对该文
件进行操作。
第八章
8.3.1 文件打开的函数fopen()
open函数用于打开一个文件,其调用的一般形式为: 文件指针名 = fopen(文件名, 使用文件方式);
“文件指针名”:必须是被说明为FILE 类型的指针变量。
“文件名”:被打开文件的文件名,“文件名”是字符串常 量、字符数组或字符指针。 “使用文件方式”:指文件的类型和操作要求。
/* 输出系统提示信息 */
上面程序段的意义是,如果返回的指针为空,表示不能 打开test.dat文件,则给出提示信息“打开文件test.dat出 错!”,然后输出系统提示信息,当用户从键盘敲任一键后 执行exit(1)退出程序 。
第八章
8.3.2 文件关闭的函数fclose()
8.指针
例 p指向int型数,则 p+1 p+12 例 p指向int型数组,且p=&a[0]; 则p+1 指向a[1] 例 int a[10]; int *p=&a[2]; p++; *p=1; 1
p+i
a[3]
a[4] a[5] a[6] a[7] a[8] a[9]
p+9
指针的算术运算: 若指针变量p1与p2都指向同一数组,如执行p2-p1, 结果是两个地址之差除以数组元素的长度。 即 p2-p1(p2-p1)/d 假设p2指向实型数组元素a[5],p2的值为2020;p1指 向a[3] ,其值为2012, 则p2-p1的结果是(2020-2012)/4=2. 这个结果是有意义的,表示p2所指的元素与p1所指的 元素之间差2个元素。 p1+p2 无实际意义
a+9
a[9] *(a+9)
p+9
*(p+9)
下标法 a[i] *(p+i) *(a+i)
指针法
例 输出数组中的全部元素。
假设有一个a数组,整型,有10个元素。要输出 各元素的值有三种方法:
(1)下标法。
(2) 通过数组名计算数组元素地址,找出元素的值。
(3) 用指针变量指向数组元素。
(1)下标法。(8-3(1).c) #include <stdio.h> void main() { int a[10]; int i; for(i=0;i<10;i++) scanf(″%d″,&a[i]); printf(″\n″); for(i=0;i<10;i++) printf(″%d″,a[i]); }
2000 3 a 2002 4 b
高教c语言程序设计课后编程题答案
第三章顺序结构3.30 编写程序,把560 分钟换算成用小时和分钟表示,然后进行输出。
※程序如下※main( ){int hour,minute;hour=560/60;minute=560%60;printf("hour=%d,minute=%d",hour,minute);}3.31 编写程序,输入两个整数:1500 和350,求出它们的商数和余数并进行输出。
※程序如下※#include<stdio.h>main( ){int numl,num2,i,j; /* 定义变量i—商,j —余数*/printf("input num1 and num2:\n");scanf("%d%d",&num1,&num2);i=n}3.32 编写程序,读入三个双精度数,求它们的平均值并保留此平均值小数点后一位数,对小数点后第二位数进行四舍五入,最后输出结果。
※程序如下※main( ){double a,b,c,average=0;printf("input a,b,c(double):\n");scanf("%lf%lf%lf",&a,&b,&c);average=(a+b+c)/3;average=average*10;average=average+0.5;average=(int)average;average=average/10;printf("average=%lf",average);}3.33编写程序,读入三个整数给a, b , c,然后交换它们中的数,把a中原来的值给b,把b中原来的值给c,把c中的值给a。
※程序如下※main( ){int a,b,c,t=0; printf("input ab c:\n"); scanf("%d%d%d",&a,&b,&c); t=c;c=b;b=a;a=t;printf("a=%d b=%d c=%d",a,b,c);}dO );并输入当前的日第四章 选择结构4.21 当 a>0 时,请将以下语句改写成 switch 语句。
C语言指针讲解
float a;
int * pointer_1;
pointer_1=&a;
编辑课件
9
在对指针变量赋值时需要注意两点:
⑴ 指针变量中只能存放地址(指针),不要将一个 整数赋给一个指针变量。
例: * pointer_1=100; /* pointer_1是指针 变量,100是整数,不合法 */
(2) 赋给指针变量的变是量地址不能是任意的类型, 而只能是与指针变量的基类型具有相同类型的变 量的
编辑课件
22
可以用一个指针变量指向一个数组元素。
例如:int a[10]; (定义a为包含10个整型数据的数组)
int *p; (定义p为指向整型变量的指针变量)
p=&a[0]; (把a[0]元素的地址赋给指针变量p) 也就是使p指向a数组的第0号元素 。
编辑课件
23
编辑课件
24
10.3.2 指针的运算
编辑课件
29
(3) 用指针变量指向数组元素。
#include <stdio.h> void main() { int a[10];
int *p,i; for(i=0;i<10;i++)
scanf(″%d″,&a[i]); printf(″\n″); for(p=a;p<(a+10);p++)
printf(″%d ″,*p); }
{ void exchange(int *q1, int *q2, int *q3);
int a,b,c,*p1,*p2,*p3;
scanf(″%d,%d,%d″,&a, &b, &c);
p1=&a;p2=&b;p3=&c;
exchange (p1,p2,p3);
c语言程序设计第五版课后答案谭浩强第八章课后答案
c语⾔程序设计第五版课后答案谭浩强第⼋章课后答案c语⾔程序设计第五版课后答案谭浩强习题答案第⼋章善于利⽤指针本章习题均要求使⽤指针⽅法处理。
1. 输⼊3个整数,要求按由⼩到⼤的顺序输出。
解题思路:先获取到三个变量的地址,然后获取三个数据,通过指针进⾏⽐较转换即可答案:#include <stdio.h>void swap(int *p_a, int *p_b){int temp = *p_a;*p_a = *p_b;*p_b = temp;}int main(){int a, b, c, *p_a = &a, *p_b = &b, *p_c = &c; // 获取每个变量空间的地址printf("Please enter three numbers:");scanf_s("%d%d%d", p_a, p_b, p_c);if (*p_a > *p_b) {swap(p_a, p_b);//通过指针进⾏指向空间内的数据交换}if (*p_a > *p_c) {swap(p_a, p_c);}if (*p_b > *p_c) {swap(p_b, p_c);}printf("%d %d %d\n", *p_a, *p_b, *p_c);system("pause");return 0;}2. 输⼊3个字符串,要求按由⼩到⼤的顺序输出。
解题思路:字符串的⽐较可以使⽤strcmp函数,返回值>0表⽰⼤于,返回值⼩于0表⽰⼩于,返回追等于0表⽰相同。
其他的⽐较排序思路与数字的排序交换没有区别,逐个进⾏⽐较先找出最⼤的,然后找出第⼆⼤的。
答案:#include <stdio.h>int main(){char str[3][32];char *p[3];printf("Please enter three strings:");for (int i = 0; i < 3; i++) {p[i] = str[i];scanf_s("%s", p[i], 32);//后边的数字限制缓冲区边界,防⽌缓冲区溢出访问越界}//让p[0]和p[1]/p[2]分别进⾏⽐较,找出最⼤的字符串,i+1之后,则让p[1]和p[2]进⾏⽐较,找出第⼆⼤//i循环总个数-1次,最后⼀个是不需要⽐较的for (int i = 0; i < 2; i++) {for (int j = i + 1; j < 3; j++) {if (strcmp(p[i], p[j]) > 0) {char *tmp = p[i]; p[i] = p[j]; p[j] = tmp;}}}printf("%s %s %s\n", p[0], p[1], p[2]);system("pause");return 0;}3. 输⼊10个整数,将其中最⼩的数与第⼀个数对换, 把最⼤的数与最后⼀个数对换。
C语言程序设计第八章 指针的使用
第八章指针的使用【学习目标】本章将详细介绍在C语言中如何使用指针。
学习要点包括如下几点:(1)掌握指针和指针变量的概念,了解指针变量的特点以及直接访问数据和间接访问数据的原理。
(2)掌握指针变量的定义、赋值方法及指针运算符的使用,熟练运用指针访问简单变量。
(3)熟悉指针和一维数组的关系,掌握指向一维数组的指针变量的定义方法,熟练使用指针变量访问一维数组元素。
(4)了解指针与字符串的关系,能熟练使用指针处理字符串。
(5)熟练掌握用指针变量作函数的参数时函数的定义和调用方法、数组名作函数的参数用法。
(6)指向指针的指针的运用。
【学习导航】本章的在整个课程中的位置如图5-1所示。
图8-1 本章学习导航在本书的第一章介绍C语言有一个灵活性的特点,那么它的灵活性具体体现在哪里呢?其实就是指针。
指针是C语言的精华部分,通过利用指针,我们能很好地利用内存资源,使其发挥最大的效率。
有了指针技术,我们可以描述复杂的数据结构,对字符串的处理可以更灵活,对数组的处理更方便,使程序的书写简洁,高效。
8.1 地址和指针指针是C语言的一种数据类型,类似于整型、字符型等。
既然指针也是一种类型,那么也可以定义该类型的变量,称为指针变量。
指针变量和其他类型的变量的区别是:指针变量存储的是地址。
所以要学好指针,就一定要明白数据在内存中是如何存储的。
计算机所有数据都是存储在存储器里,系统的内存可看作编了号的小房间,如果要取房间的东西(读取数据)就需要得到房间编号。
地址就是内存区中对每个字节的编号。
下面通过两个整型变量来说明。
整型变量x、y(基本整型需4个字节)在内存中的存储如图8-2所示(假设内存编号是从2000开始)。
把变量所占用的存储单元首字节的地址作为变量的地址。
C语言中利用取地址运算符“&”获取变量的存储地址。
例如,&c将返回c的首地址;&x将返回x的首地址。
2000H2004H2008H2012H...图8-2 变量x和y在内存中的存储图8-2中2000H和2004H就是内存单元的地址。
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)
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
第八章 地址和指针
第一节 变量的地址和指针
1、计算机的内存是以字节为单位的一片连续的存储空间,每一个字节都有一个编号,这个编号就成为内存地址。
2、程序中定义了一个变量,c 编译系统就会根据定义中变量的类型,为其分配一定字节数的内存空间:
Short int 2
Int float 4
Double 8
char 1
指针 4
图8.1 变量在内存中所占字节的地址示意图 每个变量的地址就是指该变量所占存储单元的第一个字节的地址。
3、直接存取:程序中我们对变量进行存取操作,实际上也就是对某个地址的存储单元进行操作。
这种直接按变量的地址存取变量值的方式。
4、在c 语言中,还可以定义一种特殊的变量,这种变量只
a 2001 p
3001
a b x
1012 1013 1015 1016 1201 1202 1203 1204
是用来存放内存地址的。
图8.2 存放地址的指针变量示意图
通过变量p 间接得到变量a 的地址,然后再存取变量a 的值的方式称为“间接存取”方式,通常变量p 指向了变量a ,变量a 是变量p 所指向的对象。
5、用来存放指针地址的变量就称作“指针变量”。
6、“变量p 指向变量a ”的含义就是指针变量p 中存放了变量a 的地址。
7、在某些场合,指针是使运算得以进行的唯一途径。
第二节 指针的定义赋值
一、 指针变量的定义和指针变量的基本类型
1、 定义指针变量的一般形式如下:
类型名 *指针变量名1,*指针变量名2……
说明:1)类型名是基本类型。
2)*是说明符。
(而在调用的时候,代表的是存储单元中的值)
3)指针变量名是用户标识符。
例:1)int *pi,*pj; pi pj 只能存放整型变量的地址 int I,*pi;double *pj;
2)p 为一个指向指针的指针变量
2002 2002 1012 1013
p p
int **p,*s,k=20;
s=&k;p=&s;
*p代表存储单元s,*s代表存储单元k,因此**p 也代表存储单元k
2、为什么指针变量要有“基类型”呢?
一个指针变量中存放的是一个存储单元的地址值,一个存储单元的中的“一”所代表的字节数是不同的:int float
二、给指针变量的赋值
1、通过求地址运算符(&)获得地址值
1)&用来求出运算对象地址,用求地址运算可以把
一个变量的地址赋给指针变量
2)把变量k的地址赋予q,这时可以说:q指向了变
量k。
3)求地址运算符只能应用于变量和数组元素,不可
用于表达式、常量或被说明为register的变量。
&必须放在运算对象左边,且运算对象类型必须与指针变量的基类型相同。
4)调用scanf函数时,若q=&k 则scanf(“%d”,
&k)和scanf(“%d”,q)是等价的。
2、通过指针变量获得地址值
可以通过赋值运算,把一个指针变量中的地址赋给另外一个指针变量,从而使这两个指针指向同一地址。
p=q
注意:赋值号两边的指针变量的基类型必须相同。
3、通过标准函数获得地址值
可以通过调用库函数malloc和calloc在内存中开辟动态存储单元,并把开辟的动态存储单元的地址赋给指针变量。
4、给指针变量赋“空”值
p=NULL;
NULL代码值为0,当执行了以上的赋值语句后,称p 为空指针。
以上语句等价于:
p=’\0’p=0
企图通过一个空指针去访问一个存储单元时,将会出错。
三、对指针变量的操作
1、通过指针来引用一个存储单元
1)c语言中提供了一个称作“间接访问运算符”的单目运算符“*”。
当指针变量中存放了一个确切的地址值时,就可以用*p来引用该地址的存储单元。
int *p,i=10,j;
p=&i
j=*&i
j=*p+1 指针变量p所指存储单元中的内容加1后赋予j 2)int *p,k=0;
p=&k;
*p=100 把100存放在变量k中
*p=*p+1 p所指存储单元中的值加1后,再放入p所指存储单元中,即:k变为101
*p出现在赋值号左边时,代表的是指针所指的存储单元;当*p出现在赋值号右边时,代表的是指针所指的存储单元的内容。
*p+=1 ++*p (*p)++括号不能少
2、移动指针
a[0] a[1] a[2] a[3] a[4]
p q
q=p+2; /*使指针q指向存储单元a【2】*/
q++; /*q向高地址移动指针,指向a【3】*/
q++; /*q向高地址移动指针,指向a【4】*/
q--; /*q向低地址移动指针,指向a【3】*/
p++; /*p向高地址移动指针,指向a【1】*/
q-p=2
1)所谓移动指针就是对指针变量加上或减去一个整数,或通过赋值运算,使指针变量指向相邻的存储单元。
因此只有当指针指向一串连续的存储单元时,指针的移动才有意义。
2)当指针指向一串连续的存储单元时,可以对指针变量进行加上或减去一个整数的运算,也可以对指向同一串连续存
储单元的两个指针进行相减运算。
3)在对指针进行加、减运算中,数字1不代表整数1,而是指一个存储单元长度,至于一个长度占多少个字节的存储空间,则视指针的基类型而定。
4)当移动指针时,基类型为int的指针只能用来指向int变量,不能用以指向其他类型的变量。
3、指针的比较
在关系表达式中可以对两个指针进行比较。
通常两个或多个指针指向同一目标(如同一串连续的存储单元)时比较才有意义。
四、函数之间地址值的传递
1、形参为指针变量时实参和形参之间的数据传递
若函数的形参为指针类型,调用该函数时,对应的实参必须是基类型相同的地址值或者是已指向某个存储单元的指针变量。
例:编写函数myadd(int *a,int *b),函数中把指针a和b 所指存储单元中的两个值相加,然后将和值作为函数值返回。
程序如下:
#include <stdio.h>
myadd(int *a, int *b)
{ int sum;
sum=*a+*b;
return sum;
}
main()
{ int x,y,z;
printf("input x,y:\n");
scanf("%d%d",&x,&y);
z=myadd(&x,&y);
printf("%d+%d=%d\n",x,y,z);
}
2、通过传送地址值在被调用函数中直接改变调用函数中
的变量的值
例:调用swap函数,交换主函数中变量x和y中的数据。
#include <stdio.h>
void swap(int *a, int *b)
{
int t;
printf("2) a=%d,b=%d\n",*a,*b);
t=*a;*a=*b;*b=t;
printf("3) a=%d,b=%d\n",*a,*b);
}
main()
int x=30,y=20;
printf("1) x=%d,y=%d\n",x,y);
swap(&x,&y);
printf("4) x=%d,y=%d\n",x,y);
}
在c程序中可以通过传送地址的方式在被调用函数中直接改变调用函数中的变量的值,从而达到函数之间的数据传递。
3、函数返回地址值
函数值的类型不仅可以是简单的数据类型,而且可以是指针类型。
例:编写程序,把主函数中变量i和j中存放较大数的那个地址作为函数值传回。
#include <stdio.h>
int *fun(int *,int *);
main()
{
int *p,i,j;
printf("input two number:\n");
scanf("%d%d",&i,&j);
p=fun(&i,&j);
printf("i=%d,j=%d,*p=%d\n",i,j,*p);
int *fun(int *a,int *b) {
if(*a>*b) return a;
return b;
}。