c语言 指针讲义 复习资料

合集下载

c语言 指针讲义 复习资料

c语言 指针讲义 复习资料

第十章指针 (10学时)学习目的与要求:1 、理解地址和指针的概念;2 、重点掌握指针变量的定义和引用;3 、重点掌握指向数组的指针和通过指向数组的指针操纵数组;4 、重点掌握指向字符串的指针和通过指向字符串的指针操纵字符串;5 、理解指向指针的指针、指针数组等概念。

重点:1 、指针变量的定义和引用;2 、指向数组的指针和通过指向数组的指针操纵数组;3 、指向字符串的指针和通过指向字符串的指针操纵字符串第1讲知识归纳:1、地址和指针的概念:(1) 地址:内存区的每一个字节的编号;(2) 指针:一个变量的地址称为该变量的指针,即地址就是指针,指针就是地址;2、指向变量的指针变量:(1) 指针变量:是指专门用来存放变量地址的一类变量;(2) 注意区分指针和指针变量的概念;指针是地址;指针变量是存放地址的变量;平时所说的定义一个指针,实际上是指定义一个指针变量;3、指针变量的定义和引用:(1) 定义指针变量格式:基类型* 指针变量名;(2) 如何确定指针变量的类型?要定义的指针准备指向什么类型变量,该指针就是什么类型;(3) 如何让一个指针指向一个变量?将变量的地址赋值给指针变量;& -----取地址运算符;如:int a =5 ;int * pa ;int pa = &a ;(4) 指针变量的引用:*-----取内容运算符,该运算符与指针变量结合,表示指针所指向的变量的内容;如:printf (“ % d ,%d\n “, * pa, a ) ;下面是错误的:int * pa ;printf (“ % d \n “, * pa) ;//一个指针在没有指向一个确切的存储空间时,是不能使用* pa4、指针总结:int a = 5 ;int * pa =&a ;在定义指针,并指向某个变量后,我们可以得出如下结论:(1) *pa等价于a(2) pa 等价于&a(3) & * pa 等价于&a 、pa(4) * &a 等价于a基础训练(A)一、选择题1、已知:int *p,a;则语句“p=&a;”中的运算符“&”的含义是()。

C语言期末复习整理 指针

C语言期末复习整理 指针

指针一、定义在计算机科学中,指针(Pointer)是编程语言中的一个对象,利用地址,它的值直接指向(points to)存在电脑存储器中另一个地方的值。

由于通过地址能找到所需的变量单元,可以说,地址指向该变量单元。

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

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

二、基本形式int a,*p; p=&a;char *q,c; q=&c;scanf(“%d”,&a); printf(“%d”,*p);scanf(“%c”,q);printf(“%c”,c);&:(1)&为取地址运算,作用为返回一个变量被定义时所被分配的地址。

*:(1)定义变量时在变量名前加*号,表示该变量为指针变量,定义时关键字(如int、float、char)表示该指针所指向的变量类型(2)*运算,作用为返回“此指针变量所存储的地址表示的空间”中存储的变量,简而言之,返回该指针“指向”的变量注:C++中会存在如 int &d;类定义方式,此时&不表示取地址运算而表示“引用”(作用与宏定义有些许相似之处,具体内容会在下学期学到)对于初学者而言你,可在实际操作中就把上段代码中p当作&a,*p当作a示例:三、指针与一维数组(1)在之前数组方面的学习中,我们得知数组的存储空间是连续的,因此,得到数组中任一元素的地址,即可根据指针直接获取数组中其他元素的值。

例如, int a[10],*p=&a[2];此时,*p即指向a[2],而*(p-2)指向a[0],*(p+1)指向a[3]。

(2)因为数组名单独使用可表示数组的首地址,即第一个元素的地址,因此可以按如下所示的方式定义:int a[10],*p=a;此时,*p指向a[0],*(p+3)指向a[3].注:*p可写为p[0],*(p+3)可写为p[3],[]和*有非常大的相似之处另给一个示例供大家自行思考学习(3)两种表达方式互换:a[i] <=> *(a+i)示例:四、指针与二维数组注:本部分内容建议跳过(1)、(2)的说明过程直接记住两种表达方式互换方法。

全的C语言指针详解PPT课件

全的C语言指针详解PPT课件

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

c语言(第九章)指针.讲义

c语言(第九章)指针.讲义
26
运行结果; 5 ,9 9 ,5
27
9.2 变量的指针和指向变量的指 针变量
swap(int *p1,int *p2) { int *temp; *temp=*p1; *p1=*p2; *p2=*temp; }
因为*temp所指向的单元是不可预见的,因此对 *temp赋值可能会破坏系统的正常工作状况,应 该将*p1的值赋给一个整型变量
*(a+2)、
&a[0]
&a[1]
swap(int *p1,int *p2) { int temp; temp=*p1; *p1=*p2; *p2=temp; }
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); }
*:取内容 ,指针运算符。注意与作乘运算符时 的不同(双目) 2、说明
a. &既可作用于一般变量,也可作用于指针变量
b. * 只能作用于指针变量 c. 定义指针变量时的 * 与该处的含义不同
17
9.2 变量的指针和指向变量的指 针变量
main() { int a,b; int *pointer_1, *pointer_2; a=100;b=10; pointer_1=&a; pointer_2=&b; printf("%d,%d\n",a,b); printf("%d,%d\n",*pointer_1, *pointer_2);

【C语言课件】第8章指针复习

【C语言课件】第8章指针复习
swap (p1, p2) int *p1, *p2; { int p; p = *p1; *p1 = *p2;*p2 = p; 返回 返回 }
C语言程序设计
main () { int a,b,c,*pa,*pb,*pc; scanf("%d,%d,%d",&a,&b,&c); pa=&a; swap (p1, p2) pb=&b; int *p1, *p2; pc=&c; { int p; if(*p1<*p2) swap(pb,pc); {p = *p1; *p1 = *p2;*p2 = p;} swap(pa,pb); } swap(pb,pc); printf("a=%d,b=%d,c=%d\n",a,b,c); printf("*pa=%d,*pb=%d,*pc=%d\n",*pa,*pb,*pc); }
p为指向含 个元素的一维整型数组的指针变量 为指向含n个元素的一维整型数组的指针变量 为指向含 f为返回整型数的函数 为返回整型数的函数 p为返回指针的函数,该指针指向一个整型数据 为返回指针的函数, 为返回指针的函数 p为指向函数的指针变量,该函数返回整型数 为指向函数的指针变量, 为指向函数的指针变量
C语言程序设计
例 下列定义的含义 (1)int *p[3]; ) (2)int (*p)[3]; ) (3)int *p(int); ) (4)int (*p)(int); ) (5)int *(*p)(int); ) (6)int (*p[3])(int); )
指针数组 指向一维数组的指针 返回指针的函数 指向函数的指针,函数返回int型变量 指向函数的指针,函数返回 型变量 指向函数的指针,函数返回int 型指针 指向函数的指针,函数返回 函数指针数组,函数返回int型变量 函数指针数组,函数返回 型变量

C语言讲义第06章-指针(原)

C语言讲义第06章-指针(原)

6.1 指针的含义
• 在C语言中可以定义一种特殊的变量,专 门用来存放另一变量的地址(指针), 这种变量称为指针变量。例如,指针变 量i_pointer中存储的是变量ii的地址,当 需要对变量ii进行存取时,可以通过指针 变量i_pointer获得ii的地址。这种访问方 式称为“间接访问”的方式。
6.3 指针与数组
• 在C语言中,数组名就代表数组存储的首地址, 也就是数组中第一个数组元素的地址,所以ia 和&ia[0]的值相同。因此,下面两个语句等价: pi = &ia[0] ; pi = ia ; • 注意,“pi = ia ;”的作用是“把数组ia的首元素 地址赋给指针变量pi”,而不是“把数组ia各元 素的值赋给pi”。 • 注意,数组的存储位置是由系统分配的,不允 许在程序中改变,所以数组名是一个地址常量, 不能向它赋值,下面的语句是不合法的。 • ia = pi ;ia++ ;ia-- ;
6.4 指针与函数
• 例如: int *fi (int ix , int iy) { ...... /*函数体*/ }
6.4 指针与函数
• 例6.11将数字1-12转换成相应月份的英 文名称的函数,返回值为字符指针。 例6.11源程序 • 程序运行结果为: Please input month No.(1--12): 1 January
6.3 指针与数组
• 例6.6使用指针输出二维数组的全部元 素。 例6.6源程序 • 程序的运行结果如下: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
6.3 指针与数组
• 定义指针数组的一般形式为: 类型名 (*指针变量名)[元素个数]; 例如,在程序定义一个数组指针: int (*pi)[4]; • 它表明指针变量pi指向的存储空间包含有 四个整型元素,即数组指针pi指向一个一 维数组,pi的值就是该数组的首地址

C语言 指针 复习资料

C语言   指针  复习资料

1000 1002 1004 1000 1002
a p q
有关指针的数据类型小结
定 义 int i; 定义整型变量i 含 义
int *p
int a[n]; int *p[n]; int (*p)[n]; int f(); int *p(); int (*p)();
a[3] a[4]
p q
四 指针比较 指针的关系运算和两个指针的相减 设p、q是同一基类型的指针(q>=p), q函数间地址值的传送
实参的存储地址 形参 实参—地址 形参—指针 执行函数,进行间址操作,实参的值可能改变
Ex701a 两数交换
#include <stdio.h> main() { int x=10,y=20; printf("1.x=%d y=%d\n",x,y); swap(x,y); printf("4.x=%d y=%d\n",x,y); }
1000 1002 1004 1006 a+1 1008
a
a+2 1016 p[3]—指针数组 数组元素 p[0] p[1] p[2]
3个指向整型数据 (基类型)的指针
p 1024 p+1 1026 p+2 1028
1000 1008 1016
a[0][0] [0][1] [0][2] [0][3] a[1][0] [1][1] [1][2] [1][3] a[2][0] [2][1] [2][2] [2][3] p[0] p[1] p[2]
举例
s p p p p p p p p p p str G o o d b y e \0
输入: Good bye
Ex702 分析程序的作用 #include <stdio.h> main() { char str[50],*p,*s,c; printf("Enter string:"); gets(str); p=s=str; while(*p) p++; p--; while(s<p) { c=*s; *s++=*p; *p--=c; } puts(str); } s<p c=*s *s++=*p *s=*p s++ *s='e' s++ *s='y' s++ *s='b' s++ *s=' ' s++ *p- -=c *p=c p-*p='G' p-*p='o' p-*p='o' p-*p='d' p--

《c语言教学资料》6指针

《c语言教学资料》6指针

链表在实现队列、栈等数据结构以及文件系统、操作系统等应用中非常有用。
链表与指针
THANKS
感谢您的观看。
《C语言教学资料》- 6指针
目录
指针的基本概念 指针的运算 指针与数组 指针与函数 动态内存分配与指针 指针的高级应用
01
CHAPTER
指针的基本概念
1
2
3
指针是一个变量,其值为另一个变量的地址。
指针变量存储的是地址,而不是实际的值。
通过指针变量可以间接访问其所指向的变量。
指针的定义
指针的声明和初始化
结构体指针可以方便地访问结构体中的成员变量,并且可以通过指针进行动态内存分配和释放。
结构体是一种复合数据类型,可以包含多个不同类型的数据成员。
指针与结构体
链表是一种动态数据结构,由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表通过指针实现节点之间的连接,可以方便地进行插入、删除等操作。
01
02
03
指针作为函数参数
01
02
03
返回指针的函数可以返回一个动态分配的内存地址,或者返回一个数组的首地址。
返回指针的函数需要注意返回的指针有效性,以及内存的正确释放,避免内存泄漏和野指针问题。
返回指针的函数通常用于实现动态数据结构和自定义数据类型。
返回指针的函数
函数指针
函数指针是指向函数的指针变量,可以用来存储函数的地址,实现函数作为参数传递或回调函数的使用。
指针的非运算
指针的位运算
03
CHAPTER
指针与数组
03
数组名是一个常量指针,指向数组的起始地址,不能修改。
01
数组名可以视为指向数组第一个元素的指针。

c语言第9章_指针及其应用(1)课后复习重点[1]教程

c语言第9章_指针及其应用(1)课后复习重点[1]教程
printf("a=%d,b=%d\n",a,b); printf("swapped:\n");
指针变量在使用前
必须赋值!
swap(pointer_1,pointer_2);
printf("a=%d,b=%d\n", *pointer_1,*pointer_2); return 0; } 2018/11/2
运行结果:
a:10 *pa:10
...
printf("&pa:%x(hex)\n",&pa);
return 0; }
&a:f86(hex)
pa:f86(hex) &pa:f8a(hex)
16
2018/11/2
例:输入两个数,并使其从大到小输出
int main()
{
int *p1,*p2,*p,a,b; scanf("%d,%d",&a,&b);
24
例:交换两个数—形参和实参都为指针变量
void swap(int *p1, int *p2) { int *p; int x,*p=&x; *p=*p1; *p1=*p2; *p2=*p; } int main() { int a=7,b=11; int *pointer_1=&a,*pointer_2=&b;
2018/11/2
9
例: void main( ) { int i=10; 危险! int *p; *p=i; printf("%d",*p); } 例: void main( ) { int i=10,k; int *p; p=&k; *p=i; printf("%d",*p); } 2018/11/2

C语言指针复习[详细]

C语言指针复习[详细]

C 语言指针复习* 的优先级别低于[]带着问题学习本章内容:int *p[4]; //指针数组,数组元素师指针的数组int (*p)[4]; //数组指针,一般用于操作二维数组的指针变量int *fun(); //指针函数,用于返回指针值的函数int (*fun)(); //函数指针,指向函数的指针变量1一维数组与指针1.1一维数组元素及其地址表示int a[5] = {1, 2, 3, 4, 5};1.2指向一维数组元素的指针int a[5] = {1, 2, 3, 4, 5}, *p;p = a; // p = &a[0];指针变量p与数组名a都表示数组的首地址,但数组名a是指针常量,而p是指针变量。

1.3注意(1) p++合法, 但a++不合法, 因为a是地址常量, 不能改变, 而p 是一个指针变量, 可以改变;(2) 要注意指针变量的当前值,保证它指向数组中有效的元素;(3) 注意指针变量的运算:①*p++ <=> *(p++)先取p所指向的变量,再使p自加指向下一个变量。

②*(p++) 与*(++p)不同*(++p)是先使p自加指向下一个变量,再取其值。

③(*p)++ 先取p所指向的变量,再使变量的值加 1(4) 指针变量也可以加下标p[i] = a[i] = *(p+i) 。

2二维数组和指针2.1二维数组可以看成一维数组的一维数组每行数组看成一个元素。

2.2二维数组名是一个二级指针定义:int a[3][4];二维数组名a表示二维数组的首地址,也是第0行的首地址, a <=> &a[0] 则:a <=> &a[0] <=> &(&(a[0][0]));*a <=> a[0] <=> &(a[0][0]);=================================*a 表示元素a[0][0]的地址*a+1 表示元素a[0][1]的地址*(a+1) 表示元素a[1][0]的地址*(a+2)+3 表示元素a[2][3]的地址2.3形象表示2.4看个例子//*******************double_dimensional_array.c begin #include<stdio.h>int main(int argc, char *argv[]){int a[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};//输出每一个值//第一行printf("第一行:\n");printf("**a = %d\n", **a);printf("*(*a +1) = %d\n", *(*a + 1));printf("*(*a +2) = %d\n", *(*a + 2));printf("*(*a +3) = %d\n\n", *(*a + 3));//第二行printf("第二行:\n");printf("**(a+1) = %d\n", **(a+1));printf("*(*(a+1) +1) = %d\n", *(*(a +1) + 1));printf("*(*(a+1) +2) = %d\n", *(*(a +1) + 2));printf("*(*(a+1) +3) = %d\n\n", *(*(a +1) + 3));//第三行printf("第三行:\n");printf("**(a+2) = %d\n", **(a+2));printf("*(*(a+2) +1) = %d\n", *(*(a +2) + 1));printf("*(*(a+2) +2) = %d\n", *(*(a +2) + 2));printf("*(*(a+2) +3) = %d\n", *(*(a +2) + 3));return 0;}//*******************double_dimensional_array.c end编译运行:2.5易混淆讲解2.5.1int(*p)[4]和int*p[4]int (*p)[4];------ptr为指向含4个元素的一维整形数组的指针变量(是指针)int *p[4];-------定义指针数组p,它由4个指向整型数据的指针元素组成(是数组)int (*)[4];--------实际上可以看作是一种数据类型。

C语言指针知识点总结

C语言指针知识点总结

C语⾔指针知识点总结1.指针的使⽤和本质分析(1)初学指针使⽤注意事项1)指针⼀定要初始化,否则容易产⽣野指针(后⾯会详细说明);2)指针只保存同类型变量的地址,不同类型指针也不要相互赋值;3)只有当两个指针指向同⼀个数组中的元素时,才能进⾏指针间的运算和⽐较操作;4)指针只能进⾏减法运算,结果为同⼀个数组中所指元素的下表差值。

(2)指针的本质分析①指针是变量,指针*的意义:1)在声明时,*号表⽰所声明的变量为指针。

例如:int n = 1; int* p = &n;这⾥,变量p保存着n的地址,即p<—>&n,*p<—>n2)在使⽤时,*号表⽰取指针所指向变量的地址值。

例如:int m = *p;②如果⼀个函数需要改变实参的值,则需要使⽤指针作为函数参数(传址调⽤),如果函数的参数数据类型很复杂,可使⽤指针代替。

最常见的就是交换变量函数void swap(int* a, int* b)③指针运算符*和操作运算符的优先级相同例如:int m = *p++;等价于:int m= *p; p++;2.指针和数组(1)指针、数组、数组名如果存在⼀个数组 int m[3] = {1,2,3};定义指针变量p,int *p = m(这⾥m的类型为int*,&a[0]==>int*)这⾥,其中,&m为数组的地址,m为数组0元素的地址,两者相等,但意义不同,例如:m+1 = (unsigned int)m + sizeof(*m)&m+1= (unsigned int)(&m) + sizeof(*&m)= (unsigned int)(&m) + sizeof(m)m+1表⽰数组的第1号元素,&m+1指向数组a的下⼀个地址,即数组元素“3”之后的地址。

等价操作:m[i]←→*(m+i)←→*(i+m)←→i[m]←→*(p+i)←→p[i]实例测试如下:1 #include<stdio.h>23int main()4 {5int m[3] = { 1,2,3 };6int *p = m;78 printf(" &m = %p\n", &m);9 printf(" m = %p\n", m);10 printf("\n");1112 printf(" m+1 = %p\n", m + 1);13 printf(" &m[2] = %p\n", &m[2]);14 printf(" &m+1 = %p\n", &m + 1);15 printf("\n");1617 printf(" m[1] = %d\n", m[1]);18 printf(" *(m+1) = %d\n", *(m + 1));19 printf(" *(1+m) = %d\n", *(1 + m));20 printf(" 1[m] = %d\n", 1[m]);21 printf(" *(p+1) = %d\n", *(p + 1));22 printf(" p[1] = %d\n", p[1]);2324return0;25 }输出结果为:(2)数组名注意事项1)数组名跟数组长度⽆关;2)数组名可以看作⼀个常量指针;所以表达式中数组名只能作为右值使⽤;3)在以下情况数组名不能看作常量指针:- 数组名作为sizeof操作符的参数- 数组名作为&运算符的参数(3)指针和⼆维数组⼀维数组的指针类型是 Type*,⼆维数组的类型的指针类型是Type*[n](4)数组指针和指针数组①数组指针1)数组指针是⼀个指针,⽤于指向⼀个对应类型的数组;2)数组指针的定义⽅式如下所⽰:int (*p)[3] = &m;②指针数组1)指针数组是⼀个数组,该数组⾥每⼀个元素为⼀个指针;2)指针数组的定义⽅式如下所⽰:int* p[5];3.指针和函数(1)函数指针函数的本质是⼀段内存中的代码,函数的类型有返回类型和参数列表,函数名就是函数代码的起始地址(函数⼊⼝地址),通过函数名调⽤函数,本质为指定具体地址的跳转执⾏,因此,可定义指针,保存函数⼊⼝地址,如下所⽰:int funcname(int a, int b);int(*p)(int a, int b) = funcname;上式中,函数指针p只能指向类型为int(int,int)的函数(2)函数指针参数对于函数int funcname(int a, int b);普通函数调⽤ int funcname(int, int),只能调⽤函数int func(int, int)函数指针调⽤ intname(*func)(int,int),可以调⽤任意int(int,int)类型的函数,从⽽利⽤相同代码实现不同功能,实例测试如下,假设有两个相同类型的函数func1和func2:1int func1(int a, int b, int c)2 {3return a + b + c;4 }56int func2(int a, int b, int c)7 {8return a - b - c;9 }普通函数调⽤和函数指针调⽤⽅式及结果如下所⽰1 printf("普通函数调⽤\n");2 printf("func1 = %d\n", func1(100, 10, 1));3 printf("func2 = %d\n", func2(100, 10, 1));4 printf("\n");56 printf("函数指针调⽤\n");7int(*p)(int, int, int) = NULL;8 p = func1;9 printf("p = %d\n", p(100, 10, 1));10 p = func2;11 printf("p = %d\n", p(100, 10, 1));12 printf("\n");需要注意的是,数组作为函数参数的时候,会变为函数指针参数,即:int funcname( int m[] )<——>int funcname ( int* m );调⽤函数时,传递的是数组名,即funcname(m);(3)回调函数利⽤函数指针,可以实现⼀种特殊的调⽤机制——回调函数。

C语言指针全归纳-初级版

C语言指针全归纳-初级版

C语言指针全归纳-初级版C语言作为一门较为好上手的高级计算机语言,我相信任何一个开始学习编程的人都是先从他开始入手的,但是其中的指针曾叫人叫苦不迭。

本文章旨在全面梳理C语言指针的知识点,本文章主要内容1. 什么是指针2. 指针的类型有哪些3. 野指针4. 指针的运算5. 指针和数组6. 二级指针7. 指针数组1. 什么是指针先来看看定义在计算机科学中,指针(Pointer)是编程语言中的一个对象,利用地址,它的值直接指向(points to)存在电脑存储器中的另一个地方的值。

由于通过地址能找到所需的变量单元,所以可以说,地址指向该变量单元。

因此,将地址形象化的称为‘指针’。

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

int a=10;int *p=&a;p是指针变量,存放内存单元的地址(整形占四个字节,存放首地址,其他类型亦是如此)&a是a的地址,也就是指针存入p所以说&a或p唯一指向a地址是如何产生的呢?地址就是数据在内存中的存储位置的“门牌号”计算机有32位和64位的配置,已32位为例:就是有32根地址线,可以在寻址时产生32个电信号(正或负),将电子信号转换为数字信号就是32位的01序列(64位就是64位的01序列),地址编号就是由此产生的,但是为了便于观察,我们会用16进制来进行表示。

由此也可以推断出32位机器的指针大小为4字节(32bit==4byte),64位机器的指针位8字节。

2. 指针的类型有哪些int *p1;char *p2;double *p3;float *p;…………这些指针虽然指向的数据类型不同,但本身大小都一样,那么为什么要给出这么多指针类型呢?难道不能只设置一种类型指向所有吗?比如pointer *p;接下来我们看看指针类型有什么用呢?以上黄颜色标注int* 型的指针解引用访问了四个字节的内容char* 型的指针解引用只访问了一个字节的内容由此可以看出指针类型的第一个作用:决定了指针的访问权限,即指针向后方访问几个字节所以我们想要访问几个字节就用相对应字节数类型的指针进行存储。

C语言 指针复习

C语言 指针复习





声明了一个数组TYPE array[n],则数组名称array就有了两 重含义:第一,它代表整个数组,它的类型是TYPE [n];第 二,它是一个指针,该指针的类型是TYPE*,该指针指向的 类型是TYPE,也就是数组单元的类型,该指针指向的内存 区就是数组第0号单元,该指针自己占有单独的内存区,注 意它和数组第0号单元占据的内存区是不同的。该指针的值 是不能修改的,即类似array++的表达式是错误的。 在不同的表达式中数组名array可以扮演不同的角色。 在表达式sizeof(array)中,数组名array代表数组本身,故这 时sizeof函数测出的是整个数组的大小。 在表达式*array中,array扮演的是指针,因此这个表达式的 结果就是数组第0号单元的值。sizeof(*array)测出的是数组 单元的大小。 表达式array+n(其中n=0,1,2,....。)中,array扮演的 是指针,故array+n的结果是一个指针,它的类型是TYPE*, 它指向的类型是TYPE,它指向数组第n号单元。故 sizeof(array+n)测出的是指针类型的大小。


再看例子四: 1. char a[20]; 2. int *ptr=a; ... 3. ptr+=5;
在这个例子中,ptr被加上了5,编译器是这样处理的:将指 针ptr的值加上5乘sizeof(int),在32位程序中就是加上了5乘 4=20。由于地址的单位是字节,故现在的ptr所指向的地址 比起加5后的ptr所指向的地址来说,向高地址方向移动了20 个字节。在这个例子中,没加5前的ptr指向数组a的第0号单 元开始的四个字节,加5后,ptr已经指向了数组a的合法范围 之外了。虽然这种情况在应用上会出问 题,但在语法上却是可以的。这也体现出了指针的灵活性。 如果上例中,ptr是被减去5,那么处理过程大同小异,只不 过ptr的值是被减去5乘sizeof(int),新的ptr指向的地址将比原 来的ptr所指向的地址向低地址方向移动了20个字节。

C语言指针讲义

C语言指针讲义

数组元素a[i]的地址=数组首地址+i ×数组元素的数据类型所占用的内存单元数例:int a[3]={1,2,3};三、指针变量1.什么是指针变量定义:存放地址的变量称为“指针变量”。

2.指针变量的定义和初始化指针变量在使用前必须定义,定义的同时可以赋初值。

【格式】存储类型 数据类型 *指针变量名1[=初值1],…; 【功能】定义指向指定“数据类型”或数组的若干个指针变量,同时给这些变量赋初值。

例:int a ;int *p=&a ;float f1,f[10],*p1=&f1,*p2=f ; 3.指针变量的引用方式 (1)给指针变量赋值【格式】指针变量=地址表达式 例: int i ,*p ;p=&i ; (2)直接引用指针变量名例:int i,j ,*p=&i,*q ;q=p ;scanf (“%d ,%d ”,q ,&j ); (3)通过指针变量来引用它所指向的变量 【格式】*指针变量名例如:int i=1,j=2,k ,*p=&i ;k=*p+j ; 四、取地址运算符与指针运算符 取地址运算符(&):取运算对象的地址。

如&a 指针运算符(*):取指针变量所指向的变量或数组元素的值。

例如:int *p ,a ;p=&a ;则*p= =a 为真。

【例】利用指针,求两个整数的和。

main ({ int i , j ,sum ;int *p , *q ; /*定义指针变量 p=&i ; q=&j ; /*建立关联scanf (″%d , %d ″, p , q ); sum=*p+*q ; /*使用指针变量 printf (″%d , %d\n ″, *p , *q );printf(″和= %d \n ″, sum);}地址 内存单元1 3000300130023003300430053006整型数组元素a[0] 2 3 整型数组元素a[1] 整型数组元素a[2]如何将指针变量指向数组的首地址?: *(指针变量+0)或*指针变量: *(指针变量+i)*(指针变量+0)或*指针变量*(指针变量-k): *(指针变量+k)① *(指针变量+i)②*(数组名+i)③指针变量[i]④数组名[i]main(。

C语言学习文档 第08章 指针(培训)

C语言学习文档   第08章  指针(培训)

变量pointer为指针变量,存放的是变量i的 内存地址,我们说pointer指向 i。
6.指针的概念: 一个变量的首地址称为该变量的指针。
用来专门存储变量指针的变量称为指针变量。
8.2 指针与变量
一. 指针变量的定义
1. 定义方式:
类型标识符 *指针变量名1,*指针变量名2…… ;
例:float *p1; char *p2; (定义了p1为指向实型变量的指针变量) (定义了p2为指向字符型变量的指针变量)
指针的指针
------指向指针变量的指针. 1001 定义形式: 类型 **变量名; 例如: int i,*p,**q; i=30; p=&i; q=&p;
2000 1000
内存示意图:
i
1000
p
3000
2000
q
国家等级考试练习: 1.设有定义:int n1=0,n2,*p=&n2,*q=&n1,以下赋值语句中与 A n2=n1;语句等价的是: a. *p=*q; b.p=q c.*p=&n1 d. p=*q 2.若有说明语句:double *p,a;则能通过scanf语句正确给输入 项读入数据的程序段是: D a.*p=&a;scanf(‚%lf‛,p); b.*p=&a; scanf(‚%f‛,p); c.p=&a;scanf(‚%lf‛,*p); d.p=&a;scanf(‚%lf‛,p); 3.已定义以下函数 int fun(int *p) {return *p;} fun函数的返回值是: B a.不确定的值 c.形参p中存放的值
国家等级考试练习: 1.以下叙述中错误的是: C a.改变函数形参的值,不会改变对应的实参 b.函数可以返回地址值 c.可以给指针变量赋一个整数作为地址值 d.当在函数的开头中包括头文件stdio.h时,可以给变量赋NULL

c语言 第9章_指针及其应用(1)课后复习重点[1]

c语言 第9章_指针及其应用(1)课后复习重点[1]

指针变量必须先赋值,再使用
...
2000
10
整型变量i
2004
2008
变量k
10
指针变量p 随机 2004
2012
...
10
int i; float *p; p=&i;
一个指针变量不能指向 与其类型不同的变量!
应在类型相同的指 针变量之间赋值 int *p; float *q; p=q;
int *p; p=100;
23
例:交换两个数—形参和实参都为指针变量
void swap(int *p1, int *p2) { int *p; p=p1; p1=p2; p2=p; } int main() { int a=7,b=11; int *pointer_1=&a,*pointer_2=&b;
printf("a=%d,b=%d\n",a,b); printf("swapped:\n"); 调用结束 调用前 调用中
用于存放某个内存单元地址的变量。
(指向某内存单元的指针)
例如: char c = 'K'; char *p ;
p = &c;
p(4000) 2000 c(2000)
*p
75
2015/12/30
6
指针变量的声明
指针变量的声明格式: 数据类型 *变量名; – "*": 声明一个指针类型的变量; – "数据类型":指针变量所指向的变量的数据类型。
2015/12/30
9
例: void main( ) { int i=10; 危险! int *p; *p=i; printf("%d",*p); } 例: void main( ) { int i=10,k; int *p; p=&k; *p=i; printf("%d",*p); } 2015/12/30

全国计算机等级考试笔试讲义(第7章_指针)

全国计算机等级考试笔试讲义(第7章_指针)
void swap2 (int *px, int *py) { int t; t = *px; *px = *py; *py = t; }
px
a=2, b=1
py
考点3 指针作为函数的参数 例7-5 函数参数包括实参和形参,两者的类型要一致,可以 是指针类型。如果实参是某个变量的地址,相应的形参就是指 针。 调用哪个函数,可以交换main () int main (void) 中变量a和b的值? { int a = 1, b = 2;
printf ("a=%d, b=%d, c=%d, *p1=%d, *p2=%d\n", a, b, c, *p1, *p2);
return 0;
a = 2; b = 4; c = 6; *p1 = 6, *p2 = 2
}
例7-4 int main (void ) a = 1; b = 2; *p1 = 1, *p2 = 2 { int a=1, b=2; a = 1; b = 2; *p1 = 2, *p2 = 1 int *p1 = &a, *p2 = &b, *pt; printf ("a=%d, b=%d, *p1=%d, *p2=%d\n", a, b, *p1, *p2); pt = p1; p1 = p2; p2 = pt; printf (“a=%d, b=%d, *p1=%d, *p2=%d\n”, a, b, *p1, *p2); return 0; } p1 a p1 a *p2 &b 1 *p1 &a 1 p2 b p2 b *p1 &a 2 *p2 &b 2 pt pt &a
p1
&a
a 2 1
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

第十章指针 (10学时)学习目的与要求:1 、理解地址和指针的概念;2 、重点掌握指针变量的定义和引用;3 、重点掌握指向数组的指针和通过指向数组的指针操纵数组;4 、重点掌握指向字符串的指针和通过指向字符串的指针操纵字符串;5 、理解指向指针的指针、指针数组等概念。

重点:1 、指针变量的定义和引用;2 、指向数组的指针和通过指向数组的指针操纵数组;3 、指向字符串的指针和通过指向字符串的指针操纵字符串第1讲知识归纳:1、地址和指针的概念:(1) 地址:内存区的每一个字节的编号;(2) 指针:一个变量的地址称为该变量的指针,即地址就是指针,指针就是地址;2、指向变量的指针变量:(1) 指针变量:是指专门用来存放变量地址的一类变量;(2) 注意区分指针和指针变量的概念;指针是地址;指针变量是存放地址的变量;平时所说的定义一个指针,实际上是指定义一个指针变量;3、指针变量的定义和引用:(1) 定义指针变量格式:基类型* 指针变量名;(2) 如何确定指针变量的类型?要定义的指针准备指向什么类型变量,该指针就是什么类型;(3) 如何让一个指针指向一个变量?将变量的地址赋值给指针变量;& -----取地址运算符;如:int a =5 ;int * pa ;int pa = &a ;(4) 指针变量的引用:*-----取内容运算符,该运算符与指针变量结合,表示指针所指向的变量的内容;如:printf (“ % d ,%d\n “, * pa, a ) ;下面是错误的:int * pa ;printf (“ % d \n “, * pa) ;//一个指针在没有指向一个确切的存储空间时,是不能使用* pa4、指针总结:int a = 5 ;int * pa =&a ;在定义指针,并指向某个变量后,我们可以得出如下结论:(1) *pa等价于a(2) pa 等价于&a(3) & * pa 等价于&a 、pa(4) * &a 等价于a基础训练(A)一、选择题1、已知:int *p,a;则语句“p=&a;”中的运算符“&”的含义是()。

A)位与运算B)逻辑与运算C)取指针内容D)取变量地址2、已知:double d;希望指针变量pd指向d,下面对指针变量pd的正确定义是()。

A)double pd; B)double &pd C)double *pd D)double *(pd)3、若x为整型变量,p是指向整型数据的指针变量,则正确的赋值表达式是( )。

A)p=&x B)p=x C)*p=&x D)*p=*x二、填空题1、要使指针变量与变量之间建立联系,可以用运算符来定义一个指针变量,用运算符来建立指针变量与变量之间的联系。

2、已知:int a=10,*p=&a;则“printf("%d,%d\n",a,*p);”的输出结果是。

3、已知:float f1=3.2,f2,*pf1=&f1;现在希望变量f2的值为3.2,可使用赋值语句或。

4、已知:int b=5,*p=&b;并且b的地址为4000,则“printf("%d,%d",p,*p);”的输出结果是。

三、阅读程序,回答问题。

1、main(){ int var, *p;var=100; *p=&var;var=*p+10;printf("%d",var);}运行结果:2、# include <stdio.h>void prtv(int *x){ printf("%d\n",++*x);}main(){ int a=25;prtv(&a);}运行结果:能力提高(B)一、选择题1、已知:int a,*p=&a;则下列函数调用中错误的是()。

A)scanf("%d",&a); B)scanf("%d",p);C)printf("%d",a); D)printf("%d",p);2、已知:int i=0,j=1,*p=&i,*q=&j;错误的语句是()。

A)i=*&j; B)p=&*&i; C)j=*p; D)i=*&q;3、函数的功能是交换变量x和y中的值,且通过正确调用返回交换的结果。

能正确执行此功能的函数是()。

A)funa(int *x,int *y){ int *p;*p=x; *x=*y; *y=*p;}B)funb(int x,int y){ int t;t=x; x=y; y=t;}C)func(int *x,int *y){ *x=*y; *y=*x;}D)fund(int *x,int *y){ int t;t=*x; *x=*y; *y=t;}二、阅读程序,写出运行结果1、# include <stdio.h>main(){ int a,b;a=5;b=10;printf("before swap a=%d,b=%d\n",a,b);swap(a,b);printf("after swap a=%d,b=%d\n",a,b);}swap(int x,int y){ int temp;temp=x; x=y; y=temp;printf("in swap x=%d,y=%d\n",x,y);}运行结果:2、# include <stdio.h>main(){ int a,b;a=5;b=10;printf("before swap a=%d,b=%d\n",a,b);swap(&a,&b);printf("after swap a=%d,b=%d\n",a,b);}swap(int *px,int *py){ int temp;temp=*px; *px=*py; *py=temp;printf("in swap x=%d,y=%d\n",*px,*py);}运行结果:比较上面两个程序,试说明两者的区别?第2讲知识归纳:1、指针变量做实参:(1)指针变量做实参,实质传的是指针所指向的变量的地址-----即传地址调用;(2) 指针变量做实参,形参必须是指针,即通过形参指针操纵主调函数中的变量;2、指向数组的指针变量:(1) 定义一个指向数组元素的指针变量的方法,与定义指向变量的指针变量相同;(2) 使指针指向数组首地址:将数组名赋值给已定义的指针变量;使指针指向数组的某一元素:将数组元素地址赋值给已定义的指针变量;如:int arr[ 10 ];int * p ; //定义指针变量,类型与将要指向的数组类型一致;p = arr ; //p 指针指向arr数组的首地址;等价于p = & arr[0];p = &a [ 9] ; // p 指针指向arr数组的最后一个元素arr[9] ;3、通过指针引用数组元素:int arr[ 10 ];int * p = arr ;在定义指针,并指向某个数组的首地址后,我们可以得出如下结论:(1) (1)p + i =arr + i = &arr[ i ] ,均表示arr数组的第i 个元素的地址;指针变量加1 ,即在指针当前所指向的元素的地址基础上+ 一个数组元素的字节数;即p + i*d //d是一个数组元素的字节数;(2)(2)*(p+i) = *(arr + i) = arr[i] , 均表示arr 数组的第i 个元素; (3)数组元素的两种表示方法:下标法:arr[ i ] , p [ i ] // 均表示arr数组的第i 个元素;指针法:* ( p+i) , * (arr+i) //均表示arr数组的第i 个元素;4、在使用指向数组的指针变量时,应注意的问题:int arr[ 10 ];int * p = arr ;在定义指针,并指向某个数组的首地址后:(1) p ++ ; 正确;但arr++ ; 不正确;因为arr 表示数组名,是常量,不能执行arr = arr + 1 ;(2) 要注意指针变量的当前值;(3) ) ( * p ) ++ ----表示p所指向的元素值加一;即arr [ 0] ++ ;* p ++ 、* ( p ++ ) ------ 先取指针所指向空间的内容, 即arr[0] , 然后指针pa 下移一个存储空间, 指向arr[1] ;(4) * ++pa ------指针pa 先下移一个存储空间,然后取指针所指向空间的内容;基础练习(A)一、选择题1、已知:int a[10],*p=a;则下面说法不正确的是()。

A)p指向数组元素a[0] B)数组名a 表示数组中第一个元素的地址C)int a[10],*p=&a[0];与上述语句等价D)以上均不对2、已知:int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;则不能表示数组a中元素的表达式是()。

A)*p B)a[10] C)*a D)a[p-a]二、填空题1、在C语言中,指针变量的值增1,表示指针变量指向下一个,指针变量中具体增加的字节数由系统自动根据指针变量的决定。

2、已知:int a[5],*p=a;则p指向数组元素a[0],那么p+1指向。

若“ printf("%d",p);”的输出结果是200,那么:“ printf("%d",p+1);”的输出结果是。

3、对数组元素的引用方法有两种:和。

设int a[10],*p=a;则对a[3]的引用可以是或。

4、在C程序中,可以通过三种运算来移动指针:、、。

5、设有如下定义:int a[5]={0,1,2,3,4},*p1=&a[1],*p2=&a[4];则p2-p1的值为______ ,*p2-*p1的值为。

三、阅读程序,写出运行结果1、main(){ int a[10],i,*p;*p=a;for (i=0; i<10; i++)scanf("%d",&a[i]);for (;p<a+10;p++)printf("%d",*p);}执行程序,输入:0 1 2 3 4 5 6 7 8 9运行结果:2、main(){ int a[10],*p;p=&a[0];for (;p<a+10;p++)scanf("%d",p);p=a;for (p=a+9; p>=a; p--)printf("%d",*p);}执行程序,输入:0 1 2 3 4 5 6 7 8 9运行结果:能力提高(B)一、选择题1、已知:int a[]={1,2,3,4},y,*p=&a[1];则执行语句"y=*p++;"之后,变量y的值为()。

相关文档
最新文档