目录
指针
1.关于内存那点事
2.指针的概念
3.指针变量的定义方法
1.简单的指针变量
2.关于指针的运算符
3.指针大小
4.指针的分类
1:字符指针
2：短整型指针
3：整型指针
4：长整型指针
5：float 型的指针
6：double 型的指针
7：函数指针
8、结构体指针
9、指针的指针
10、数组指针
11、通用指针 void *p;
5.指针和变量的关系
6.指针和数组元素之间的关系
数组元素的引用方法
指针的运算
7.指针数组
1、指针和数组的关系
2、指针数组的定义方法：
3、指针数组的分类
8.指针的指针
9.字符串和指针
字符串的概念：
字符串的存储形式： 数组、文字常量区、堆
字符串的可修改性：
10.数组指针
1、二维数组
2、数组指针的概念：
3、数组指针的定义方法：
4、各种数组指针的定义：
5、三维数组指针，加 1 后指向下个三维数组
6、四维数组指针，加 1 后指向下个四维数组，以此类推。。。。
7、注意：
8、数组名字取地址：变成 数组指针
9、数组名字和指针变量的区别：
10、数组指针取*
11.指针和函数的关系
指针作为函数的参数
12.指针作为函数的返回值
13.指针保存函数的地址（函数指针）
1、函数指针的概念：
2、函数指针的用处：
3、函数指针变量的定义
4、调用函数的方法
5、函数指针数组
6、函数指针应用举例
14.经常容易混淆的指针概念
15.特殊指针
1、空类型的指针（void *）
2、NULL
指针 1.关于内存那点事 存储器：存储数据器件 外存 外存又叫外部存储器，长期存放数据，掉电不丢失数据 常见的外存设备：硬盘、 flash 、 rom 、 u 盘、光盘、磁带 内存 内存又叫内部存储器，暂时存放数据，掉电数据丢失 常见的内存设备： ram 、 DDR 物理内存：实实在在存在的存储设备 虚拟内存： *** 作系统虚拟出来的内存。 *** 作系统会在物理内存和虚拟内存之间做映射。 在 32 位系统下，每个进程（运行着的程序）的寻址范围是 4G,0x00 00 00 00 ~0xff ff ff ff 在写应用程序的，咱们看到的都是虚拟地址。 在运行程序的时候， *** 作系统会将 虚拟内存进行分区。 1.堆 在动态申请内存的时候，在堆里开辟内存。 2.栈 主要存放局部变量（在函数内部，或复合语句内部定义的变量）。 3.静态全局区 1 ）：未初始化的静态全局区 静态变量（定义的时候，前面加 static 修饰），或全局变量 ，没有初始化的，存在此区 2 ）：初始化的静态全局区 全局变量、静态变量，赋过初值的，存放在此区 4.代码区 存放咱们的程序代码 5.文字常量区 存放常量的。 内存以字节为单位来存储数据的，咱们可以将程序中的虚拟寻址空间，看成一个很大的一维的字符数组 2.指针的概念 系统给虚拟内存的每个存储单元分配了一个编号，从 0x00 00 00 00 ~0xff ff ff ff 这个编号咱们称之为地址 指针就是地址 指针变量：是个变量，是个指针变量，即这个变量用来存放一个地址编号 在 32 位平台下，地址总线是 32 位的，所以地址是 32 位编号，所以指针变量是 32 位的即 4 个字节。 注意： 1 ： 无论什么类型的地址，都是存储单元的编号，在 32 位平台下 都是 4 个字节， 即任何类型的指针变量都是 4 个字节大小 2 ：对应类型的指针变量，只能存放对应类型的变量的地址 举例：整型的指针变量，只能存放整型变量的地址
扩展 ： 字符变量 char ch= ‘b’ ; ch 占 1 个字节，它有一个地址编号，这个地址编号就是 ch 的地址 整型变量 int a=0x12 34 56 78; a 占 4 个字节，它占有 4 个字节的存储单元，有 4 个地址编号。 3.指针变量的定义方法 1.简单的指针变量 数据类型 * 指针变量名 ; int * p;// 定义了一个指针变量 p 在 定义指针变量的时候 * 是用来修饰变量的，说明变量 p 是个指针变量。 变量名是 p 2.关于指针的运算符 & 取地址 、 * 取值、 例1：
int a=0x1234abcd;
int *p;
//在定义指针变量的时候*代表修饰的意思，修饰 p 是个指针变量。
p=&a;
//把 a 的地址给 p 赋值 ，&是取地址符，int num ； num=*p; 分析： 1 、在调用的时候 * 代表取值得意思 ， *p 就相当于 p 指向的变量，即 a ， 2 、故 num=*p 和 num =a 的效果是一样的。 3 、所以说 num 的值为 0x1234abcd 。 扩展： 如果在一行中定义多个指针变量，每个指针变量前面都需要加 * 来修饰 int *p,*q;// 定义了两个整型的指针变量 p 和 q int * p,q;// 定义了一个整型指针变量 p ，和整型的变量 q
例2：
int main() {
int a= 100, b = 200;
int *p_1, *p_2 = &b;
//表示该变量的类型是一个指针变量，指针变量名是 p_1 而不是*p_1.
//p_1 在定义的时候没有赋初值，p_2 赋了初值
p_1＝&a；
//p_1 先定义后赋值
printf("%d\n", a); printf("%d\n", *p_1);
printf("%d\n", b); printf("%d\n", *p_2);\
return 0;
}return 0;
}4.指针的分类 按指针指向的数据的类型来分 1:字符指针 字符型数据的地址 char *p;// 定义了一个字符指针变量，只能存放字符型数据的地址编号 char ch; p= &ch; 2：短整型指针 short int *p;// 定义了一个短整型的指针变量 p ，只能存放短整型变量的地址 short int a; p =&a; 3：整型指针 int *p;// 定义了一个整型的指针变量 p ，只能存放整型变量的地址 int a; p =&a; 注：多字节变量，占多个存储单元，每个存储单元都有地址编号， c 语言规定，存储单元编号最小的那个编号，是多字节变量的地址编号。 4：长整型指针 long int *p;// 定义了一个长整型的指针变量 p ，只能存放长整型变量的地址 long int a; p =&a; 5：float 型的指针 float *p;// 定义了一个 float 型的指针变量 p ，只能存放 float 型变量的地址 float a; p =&a; 6：double 型的指针 double *p;// 定义了一个 double 型的指针变量 p ，只能存放 double 型变量的地址 double a; p =&a; (下面的指针后面会讲) 7：函数指针 8、结构体指针 9、指针的指针 10、数组指针 11、通用指针 void *p; 总结 : 无论什么类型的指针变量，在 32 位系统下，都是 4 个字节。 指针只能存放对应类型的变量的地址编号。 5.指针和变量的关系 指针可以存放变量的地址编号 int a=100; int *p; p=&a; 在程序中，引用变量的方法 1: 直接通过变量的名称 int a; a=100; 2: 可以通过指针变量来引用变量 int *p;// 在定义的时候， * 不是取值的意思，而是修饰的意思，修饰 p 是个指针变量 p=&a;// 取 a 的地址给 p 赋值， p 保存了 a 的地址，也可以说 p 指向了 a *p= 100;// 在调用的时候 * 是取值的意思， * 指针变量 等价于指针指向的变量 注：指针变量在定义的时候可以初始化 int a; int *p=&a;// 用 a 的地址，给 p 赋值，因为 p 是指针变量 指针就是用来存放变量的地址的。 *+ 指针变量 就相当于指针指向的变量 例 5： #include
例 6： #include
注意： p 和 a 的不同， p 是指针变量，而 a 是个常量。所以可以用等号给 p 赋值，但不能给 a 赋值。 p=&a[3];// 正确 a=&a[3];// 错误 方法 3 ：通过指针变量运算加取值的方法来引用数组的元素 int a[5]; int *p; p=a; *(p+2)=100;// 也是可以的，相当于 a[2]=100 解释： p 是第 0 个元素的地址， p+2 是 a[2] 这个元素的地址。 对第二个元素的地址取值，即 a[2] 方法 4 ：通过数组名 + 取值的方法引用数组的元素 int a[5]; *(a+2)=100;// 也是可以的，相当于 a[2]=100; 注意： a+2 是 a[2] 的地址。这个地方并没有给 a 赋值。 例 8： #include
3. 两个相同类型的指针可以做减法 前提： 必须是 两个相同类型的指针 指向 同一个数组的元素 的时候，做减法才有意义 做减法的结果是，两个指针指向的中间有多少个元素 例 12: #includeint main(int argc, char *argv[]) { int a[5]; int *p,*q; p=&a[0]; q=&a[3]; printf("%d\n",q-p); return 0; } 结果是 3 4 ：两个相同类型的指针可以相互赋值 注意 : 只有相同类型的指针才可以相互赋值（ void * 类型的除外） int *p; int *q; int a; p=&a;//p 保存 a 的地址， p 指向了变量 a q=p; // 用 p 给 q 赋值， q 也保存了 a 的地址，指向 a 注意：如果类型不相同的指针要想相互赋值，必须进行强制类型转换 注意： c 语言规定数组的名字，就是数组的首地址，就是数组第 0 个元素的地址，是个常量 int *p; int a[5]; p=a; p=&a[0]; 这两种赋值方法是等价的 7.指针数组 1、指针和数组的关系 1 ：指针可以保存数组元素的地址 2 ：可以定义一个数组，数组中有 若干个相同类型指针变量 ，这个数组被称为指针数组 int *p[5] 指针数组的概念： 指针数组本身是个数组，是个指针数组 ，是若干个相同类型的指针变量构成的集合 2、指针数组的定义方法： 类型说明符 * 数组名 [ 元素个数 ]; int * p[5];// 定义了一个整型的指针数组 p ，有 5 个元素 p[0]~p[4], 每个元素都是 int * 类型的变量 int a; p[0]=&a; int b[10]; p[1]=&b[5]; p[2] 、 *(p+2) 是等价的，都是指针数组中的第 2 个元素。 例 13： #include int main(int argc, char *argv[]) { char *name[5] = {"hello","China","beijing","project","Computer"}; int i; for(i=0;i<5;i++) { printf("%s\n",name[i]); } return 0; } “hello” 、“ China ”“ beijing ” “ project ” “ computer ” 这 5 个字符串存放在文字常量区。 假设： “ hello ”首地址是 0x00002000 “ China ”首地址是 0x00003000 “ beijing ”首地址是 0x00004000 “ project ”首地址是 0x00005000 “ Computer ”首地址是 0x00006000 则： name[0] 中存放内容为 0x00002000 name[1] 中存放内容为 0x00003000 name[2] 中存放内容为 0x00004000 name[3] 中存放内容为 0x00005000 name[4] 中存放内容为 0x00006000
3、指针数组的分类 字符指针数组 char *p[10] 、短整型指针数组、整型的指针数组、长整型的指针数组 float 型的指针数组、 double 型的指针数组 结构体指针数组、函数指针数组 8.指针的指针 指针的指针，即指针的地址， 咱们定义一个指针变量本身指针变量占 4 个字节，指针变量也有地址编号。 例： int a=0x12345678 ； 假如： a 的地址是 0x00002000 int *p; p =&a; 则 p 中存放的是 a 的地址编号即 0x00002000 因为 p 也占 4 个自己内存，也有它自己的地址编号，及指针变量的地址，即指针的指针。 假如：指针变量 p 的地址编号是 0x00003000 ，这个地址编号就是指针的地址 我们定义一个变量存放 p 的地址编号，这个变量就是指针的指针 int **q; q=&p;//q 保存了 p 的地址，也可以说 q 指向了 p 则 q 里存放的就是 0x00003000 int ***m; m=&q;
p q m 都是指针变量，都占 4 个字节，都存放地址编号，只不过类型不一样而已
9.字符串和指针 字符串的概念： 字符串就是以 ’结尾的若干的字符的集合：比如“’ helloworld ”。 字符串的地址，是第一个字符的地址。如：字符串“ helloworld ”的地址，其实是字符串中字符 ’h’ 的地址。 我们可以定义一个字符指针变量保存字符串的地址 , 比如： char *s =”helloworld”; 字符串的存储形式： 数组、文字常量区、堆 1 、 字符串存放在数组中 其实就是在内存（栈、静态全局区）中开辟了一段空间存放字符串。 char string[100] = “I love C!” 定义了一个字符数组 string, 用来存放多个字符，并且用 ”I love C!” 给 string 数组初始化 ， 字符串“I love C！”存放在 string 中。 注： 普通全局数组，内存分配在静态全局区 普通局部数组，内存分配在栈区。 静态数组（静态全局数组、静态局部数组），内存分配在静态全局区 2 、 字符串存放在文字常量区 在文字常量区开辟了一段空间存放字符串，将字符串的 首地址 付给指针变量。 char *str = “I love C!” 定义了一个指针变量 str, 只能存放字符地址编号， I love C ！ 这个字符串中的字符不是存放在 str 指针变量中。 str 只是存放了字符 I 的地址编号，“ I love C ！”存放在文字常量区 3 、 字符串存放在堆区 使用 malloc 等函数在堆区申请空间，将字符串拷贝到堆区。 char *str =(char*)malloc(10);// 动态申请了 10 个字节的存储空间， 首地址给 str 赋值。 strcpy(str,"I love C") ； // 将字符串“Ｉ love C! ”拷贝到 str 指向的内存里 字符串的可修改性： 字符串内容是否可以修改，取决于字符串存放在哪里 1. 存放在数组中的字符串的内容是可修改的 char str[100]=”I love C!”; str[0]= ‘y’ ;// 正确可以修改的 注：数组没有用 const 修饰 2. 文字常量区里的内容是不可修改的 char *str=”I love C!”; *str =’y’;// 错误， I 存放在文字常量区，不可修改 注： 1 、 str 指向文字常量区的时候，它指向的内存的内容不可被修改。 2 、 str 是指针变量可以指向别的地方，即可以给 str 重新赋值，让它指向别的地方。 3. 堆区的内容是可以修改的 char *str =(char*)malloc(10); strcpy(str,"I love C"); *str=’y’;// 正确，可以，因为堆区内容是可修改的 注： 1 、 str 指向堆区的时候， str 指向的内存内容是可以被修改的。 2 、 str 是指针变量，也可以指向别的地方。即可以给 str 重新赋值，让它指向别的地方 注意： str 指针指向的内存能不能被修改，要看 str 指向哪里。 str 指向文字常量区的时候，内存里的内容不可修改 str 指向数组（非 const 修饰）、堆区的时候，它指向内存的内容是可以修改 初始化： 1. 字符数组初始化： char buf_aver[20]="hello world"; 2. 指针指向文字常量区，初始化： char *buf_point="hello world"; 3 、指针指向堆区，堆区存放字符串。 不能初始化，只能先给指针赋值，让指针指向堆区，再使用 strcpy 、 scanf 等方法把字符串拷贝到堆区。 char *buf_heap; buf_heap=(char *)malloc(15); strcpy(buf_heap,"hello world"); scanf(“%s”,buf_heap); 使用时赋值 1. 字符数组：使用 scanf 或者 strcpy char buf[20]=”hello world” buf="hello kitty"; 错误 , 因为字符数组的名字是个常量 , 不能用等号给常量赋值。 strcpy(buf,"hello kitty"); 正确，数组中的内容是可以修改的 scanf("%s",buf); 正确，数组中的内容是可以修改的 2. 指针指向文字常量区 char *buf_point = “hello world”; 1) buf_point="hello kitty"; 正确 ,buf_point 指向另一个字符串 2) strcpy(buf_point,"hello kitty"); 错误，这种情况， buf_point 指向的是文字常量区，内容只读。 当指针指向文字常量区的时候，不能通过指针修改文字常量区的内容。 3. 指针指向堆区，堆区存放字符串 char *buf_heap; buf_heap=(char *)malloc(15); strcpy(buf_heap,"hello world"); scanf(“%s”,buf_heap); 字符串和指针总结： 1 、指针可以指向文字常量区 1 ）指针指向的文字常量区的内容不可以修改 2 ）指针的指向可以改变，即可以给指针变量重新赋值，指针变量指向别的地方。 2 、指针可以指向堆区 1 ）指针指向的堆区的内容可以修改。 2 ）指针的指向可以改变，即可以给指针变量重新赋值，指针变量指向别的地方。 3 、指针也可以指向数组（非 const 修饰） 例： char buf[20]="hello world"; char *str=buf; 这种情况下 1. 可以修改 buf 数组的内容。 2. 可以通过 str 修改 str 指向的内存的内容，即数组 buf 的内容 3. 不能给 buf 赋值 buf= “ hello kitty ”；错误的。 4. 可以给 str 赋值，及 str 指向别处。 str= “ hello kitty ” 1 10.数组指针 、二维数组 二维数组，有行，有列。二维数组可以看成有多个一维数组构成的，是多个一维数组的集合，可以认 为二维数组的每一个元素是个一维数组。 例： int a[3][5]; 定义了一个 3 行 5 列的一个二维数组。 可以认为二维数组 a 由 3 个一维数组构成，每个元素是一个一维数组。 回顾： 数组的名字是数组的首地址，是第 0 个元素的地址，是个常量，数组名字加 1 指向下个元素 二维数组 a 中 ， a+1 指向下个元素，即下一个一维数组，即下一行。 例 14： int main(int argc, char *argv[]) #include{ int a[3][5]; printf("a=%p\n",a); printf("a+1=%p\n",a+1); return 0; } 2 、数组指针的概念： 本身是个指针，指向一个数组，加 1 跳一个数组，即指向下个数组。 3 、数组指针的定义方法： 指向的数组的类型（ * 指针变量名） [ 指向的数组的元素个数 ] int (*p)[5];// 定义了一个数组指针变量 p ， p 指向的是整型的有 5 个元素的数组 p+1 往下指 5 个整型，跳过一个有 5 个整型元素的数组。 例 15： int main() #include { int a[3][5];//定义了一个 3 行 5 列的一个二维数组 int(*p)[5];//定义一个数组指针变量 p，p+1 跳一个有 5 个元素的整型数组 printf("a=%p\n",a);//第 0 行的行地址 printf("a+1=%p\n",a+1);//第 1 行的行地址，a 和 a +1 差 20 个字节 p=a; printf("p=%p\n",p); printf("p+1=%p\n",p+1);//p+1 跳一个有 5 个整型元素的一维数组 return 0; } 例 16：数组指针的用法 void fun(int(*p)[5],int x,int y) #include { p[0][1]=101; } int main() { int i,j; int a[3][5]; fun(a,3,5); for(i=0;i<3;i++) { for(j=0;j<5;j++) { printf("%d ",a[i][j]); } printf("\n"); } } 4 、各种数组指针的定义： (1) 、一维数组指针，加 1 后指向下个一维数组 int(*p)[5] ; // 配合每行有 5 个 int 型元素的二维数组来用 int a[3][5] int b[4][5] int c[5][5] int d[6][5] ….. p=a; p=b; p=c; p=d; 都是可以的 ~~~~ (2) 、二维数组指针，加 1 后指向下个二维数组 int(*p)[4][5]; 配合三维数组来用，三维数组中由若干个 4 行 5 列二维数组构成 int a[3][4][5]; int b[4][4][5]; int c[5][4][5]; int d[6][4][5]; 这些三维数组，有个共同的特点，都是有若干个 4 行 5 的二维数组构成。 p=a; p=b; p=c; p=d; 例 17： int main() #include
{ int a[3][4][5]; printf("a=%p\n",a); printf("a+1=%p\n",a+1);//a 和 a+1 地址编号相差 80 个字节 //验证了 a+1 跳一个 4 行 5 列的一个二维数组 int(*p)[4][5]; p=a; printf("p=%p\n",p); printf("p+1=%p\n",p+1);//p 和 p+1 地址编号相差也 80 个字节 return 0; } 5 、三维数组指针，加 1 后指向下个三维数组 int(*p)[4][5][6]; p+1 跳一个三维数组； 什么样的三维数组啊？ 由 4 个 5 行 6 列的二维数组构成的三维数组 配合： int a[7][4][5][6]; 6 、四维数组指针，加 1 后指向下个四维数组，以此类推。。。。 7 、注意： 容易混淆的概念： 指针 数组 ：是个数组，有若干个相同类型的指针构成的集合 int *p[10]; 数组 p 有 10 个 int * 类型的指针变量构成，分别是 p[0] ~p[9] 数组 指针 ：本身是个指针，指向一个数组，加 1 跳一个数组 int (*p)[10]; P 是个指针， p 是个数组指针， p 加 1 指向下个数组，跳 10 个整形。 指针的 指针 ： int **p;//p 是指针的指针 int *q; p=&q; 8 、数组名字取地址：变成 数组指针 一维数组名字取地址，变成一维数组指针，即加 1 跳一个一维数组 int a[10]; a+1 跳一个整型元素，是 a[1] 的地址 a 和 a+1 相差一个元素， 4 个字节 &a 就变成了一个一维数组指针 , 是 int(*p)[10] 类型的。 (&a) +1 和 &a 相差一个数组即 10 个元素即 40 个字节。 例 18： int main() #include { int a[10]; printf("a=%p\n",a); printf("a+1=%p\n",a+1); printf("&a=%p\n",&a); printf("&a +1=%p\n",&a+1); return 0; } a 是个 int * 类型的指针，是 a[0] 的地址。 &a 变成了数组指针，加 1 跳一个 10 个元素的整型一维数组 在运行程序时，大家会发现 a 和 &a 所代表的地址编号是一样的，即他们指向同一个存储单元，但是 a 和 &a 的指针类型不同。 例 19： int a[4][5]; a+1 跳 5 个整型 (&a)+1 跳 4 行 5 列（80 个字节） 总结： c 语言规定，数组名字取地址，变成了数组指针。加 1 跳一个数组。 9 、数组名字和指针变量的区别： int a[5]; int *p; p=a; 相同点： a 是数组的名字，是 a[0] 的地址， p=a 即 p 保存了 a[0] 的地址，即 a 和 p 都指向 a[0] ，所以在引用数组 元素的时候， a 和 p 等价 引用数组元素回顾： a[2] 、 *(a+2) 、 p[2] 、 *(p+2) 都是对数组 a 中 a[2] 元素的引用。 int main() #include { int a[5] = { 0,1,2,3,4 }; int* p; p = a; printf("a[2]=%d\n",a[2]); printf(" * (a + 2) = % d\n",*(a+2)); printf("p[2]=%d\n", p[2]); printf(" * (p + 2) = % d\n", *(p + 2)); return 0; } 不同点： 1 、 a 是常量、 p 是变量 可以用等号 ’=’ 给 p 赋值，但是不能用等号给 a 赋值 2 、 对 a 取地址，和对 p 取地址结果不同 因为 a 是数组的名字，所以对 a 取地址结果为数组指针。 p 是个指针变量，所以对 p 取地址（ &p ）结果为指针的指针。 例： int a[5]={0,1,2,3,4}; int *p=a; 假如 a[0] 的地址为 0x00002000,p 的地址为 0x00003000 1 、 &p 是指针的指针，为 int ** 类型，结果为 0x00003000 ， &p +1 ，往后指向一个 int* 类型的指 针，地址编号差 4 2 、 &a 结果是数组指针，为 int(* )[5] 类型，结果还是 0x00002000 ， &a +1 , 往后指一个数组（有 5 个整型元素的一维数组），地址编号差 20 例 20： int main(int argc, char *argv[]) #include { int a[5]; int *p; p=a; printf("a=%p\n",a); printf("&a=%p\n",&a); printf("&a +1 =%p\n",&a +1); printf("p=%p\n",p); printf("&p=%p\n",&p); printf("&p +1=%p\n",&p +1); return 0; } 10
、数组指针取* 数组指针取 * ，并不是取值的意思，而是指针的类型发生变化： 一维数组指针取 * ，结果为它指向的一维数组第 0 个元素的地址，它们还是指向同一个地方。 二维数组指针取 * ，结果为一维数组指针，它们还是指向同一个地方。 三维数组指针取 * ，结果为二维数组指针，它们还是指向同一个地方。 多维以此类推 例 21： int main() #include{ int a[3][5]; int(*p)[5]; p = a; printf("a=%p\n", a);//a 是一维数组指针，指向第 0 个一维数组，即第 0 行 printf("*a=%p\n", *a);//*a 是 第 0 行第 0 个元素的地址，即 &a[0][0] printf("*a +1=%p\n", *a + 1);//*a +1 是第 0 行第 1 个元的地址，即&a[0][1] printf("p=%p\n",p);//p 是一维数组指针，指向第 0 个一维数组，即第 0 行 printf("*p=%p\n",*p);//*p 是第 0 行第 0 个元素的地址，即 &a[0][0] printf("*p +1=%p\n", *p + 1);//*p +1 是第 0 行第 1 个元的地址，即&a[0][1] return 0; } 11.指针和函数的关系 指针作为函数的参数 咱们可以给一个函数传一个 整型、字符型、浮点型的数据，也可以 给函数传一个地址。
例： int num; scanf("%d",&num); 函数传参： (1) 、传数值： 例 22: void swap(int x,int y) { int temp; temp=x; x=y; y=temp; } int main() { int a=10,b=20; swap(a,b); printf("a=%d b=%d\n",a,b);//a=10 b=20 } 实参：调用函数时传的参数。 形参：定义被调函数时，函数名后边括号里的数据 结论：给被调函数传数值，只能改变被调函数形参的值，不能改变主调函数实参的值 (2) 、传地址 例 23： void swap(int *p1,int *p2) { int temp; temp= *p1; *p1=*p2;// p2 指向的变量的值，给 p1 指向的变量赋值 *p2=temp; } int main() { int a=10,b=20; swap(&a,&b); printf("a=%d b=%d\n",a,b);//结果为 a=20 b=10 } 结论：调用函数的时候传变量的地址，在被调函数中通过 *+ 地址来改变主调函数中的变量的值 例 24： void swap(int *p1,int *p2)//&a &b { int *p; p=p1; p1=p2;//p1 =&b 让 p1 指向 main 中的 b p2=p;//让 p2 指向 main 函数中 a }//此函数中改变的是 p1 和 p2 的指向，并没有给 main 中的 a 和 b 赋值 int main() { int a=10,b=20; swap(&a,&b); printf("a=%d b=%d\n",a,b);//结果为 a=10 b=20 } 总结：要想改变主调函数中变量的值，必须传变量的地址， 而且还得通过 *+ 地址 去赋值 。 例 25： void fun(char *p) { p="hello kitty"; } int main() { char *p="hello world"; fun(p); printf("%s\n",p);//结果为： hello world }答案分析：
在 fun 中改变的是 fun 函数中的局部变量 p ，并没有改变 main 函数中的变量 p ，所以 main 函数中的， 变量 p 还是指向 hello world 。 例 26： void fun(char **q) { *q="hello kitty"; } int main() { char *p="hello world"; fun(&p); printf("%s\n",p);//结果为：hello kitty } 总结一句话：要想改变主调函数中变量的值，必须传变量的地址，而且还得通过*+地址 去赋值。无 论这个变量是什么类型的。 (3) 给函数传数组： 给函数传数组的时候，没法一下将数组的内容作为整体传进去。 只能传数组名进去，数组名就是数组的首地址，即只能把数组的地址传进去。 也就是说，只能传一个 4 个字节大小的地址编号进去 例 27：传一维数组的地址 //void fun(int p[])//形式 1 void fun(int *p)//形式 2 { printf("%d\n",p[2]); printf("%d\n",*(p+3)); } int main() { int a[10]={1,2,3,4,5,6,7,8}; fun(a); return 0; } 例 28：传二维数组的地址 //void fun( int p[][4] )//形式 1 void fun( int (*p)[4] )//形式 2 } { int main() { fun(a); int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; return 0; } 例 29：传指针数组 void fun(char **q) // char *q[] { int i; for(i=0;i<3;i++) printf("%s\n",q[i]); } int main() { char *p[3]={"hello","world","kitty"}; //p[0] p[1] p[2] char * fun(p); return 0; } 12.指针作为函数的返回值 一个函数可以返回整型数据、字符数据、浮点型的数据，也可以返回一个指针。例 30：
char * fun() { char str[100]="hello world"; return str; } int main() { char *p; p=fun(); printf("%s\n",p);// } // 总结：返回地址的时候，地址指向的内存的内容不能释放 如果返回的指针指向的内容已经被释放了，返回这个地址，也没有意义了。 例 31 ：返回静态局部数组的地址 char * fun() { static char str[100]="hello world"; return str; } int main() { char *p; p=fun(); printf("%s\n",p);//hello world } 是，静态数组的内容，在函数结束后，亦然存在。 原因 例 32：返回文字常量区的字符串的地址 char * fun() { char *str="hello world"; return str; } int main() { char *p; p=fun(); printf("%s\n",p);//hello world } 原因是文字常量区的内容，一直存在 例 33：返回堆内存的地址 char * fun() { char *str; str=(char *)malloc(100); strcpy(str,"hello world"); return str; } int main() { char *p; p=fun(); printf("%s\n",p);//hello world free(p); } 原因是堆区的内容一直存在，直到 free 才释放 总结：返回的地址，地址指向的内存的内容得存在，返回的地址才有意义。 13.指针保存函数的地址（函数指针） 1 、函数指针的概念： 咱们定义的函数，在运行程序的时候，会将函数的指令加载到内存 的代码段。所以函数也有起始地址。 c 语言规定：函数的名字就是函数的首地址，即函数的入口地址 咱们就可以定义一个指针变量，来存放函数的地址。 这个指针变量就是函数指针变量。 2 、函数指针的用处： 函数指针用来保存函数的入口地址。 在项目开发中，我们经常需要编写或者调用带函数指针参数的函数。 比如 Linux 系统中创建多线程的函数，它有个参数就是函数指针，接收线程函数的入口地址，即创建线程 成功后，新的任务执行线程函数。 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *) , void *arg); void *thread_fun1(void *arg) } { void * thread_fun2(void *arg) } { int main() pthread_t tid1,tid2; { pthread_create(&tid1,NULL,thread_fun1,NULL); pthread_create(&tid2,NULL,thread_fun2,NULL); 。。。。 } 3 、函数指针变量的定义 返回值类型 (* 函数指针变量名 )( 形参列表 ); int(*p)(int,int);// 定义了一个函数指针变量 p,p 指向的函数 必须有一个整型的返回值，有两个整型参数。 int max(int x,int y) } { int min(int x,int y) } { 可以用这个 p 存放这类函数的地址。 p=max; p=min; 4 、调用函数的方法 1. 通过函数的名字去调函数（最常用的） int max(int x,int y) } { int main() { int num; num=max(3,5); } 2. 可以通过函数指针变量去调用 int max(int x,int y) } { int main() { int num; int (*p)(int ,int); p=max; num=(*p)(3,5); } 5 、函数指针数组 概念：由若干个相同类型的函数指针变量构成的集合，在内存中连续的顺序存储。 函数指针数组是个数组，它的每个元素都是一个函数指针变量。 函数指针数组的定义： 类型名 (* 数组名 [ 元素个数 ]) （形参列表） int(*p[5])(int,int); 定义了一个函数指针数组，数组名是 p ，有 5 个元素 p[0] ~p[4] ，每个元素都是函数指针变量， 每个函数指针变量指向的函数，必须有整型的返回值，两个整型参数。 例： int max(int x, int y) #include{ int temp; temp = x; if (x > y) else temp = y; return temp; } int min(int x, int y) { int temp; if (x < y) temp = x; else temp = y; return temp; } int add(int x, int y) { return x + y; } int sub(int x, int y) { return x - y; } int mux(int x, int y) { return x * y; } int main() { int(*p[5])(int, int) = {mux,min,add,sub,mux}; int num; num = (*p[2])(10,20); printf("num=%d\n", num); return 0; } 6 、函数指针应用举例 给函数传参 int add(int x,int y) #include { return x+y; } int sub(int x,int y) { return x-y; } int mux(int x,int y) { return x*y; } int dive(int x,int y) { return x/y; } int process(int (*p)(int ,int),int a,int b) { int ret; ret = (*p)(a,b); return ret; } int main() { int num; num = process(add,2,3); printf("num =%d\n",num); num = process(sub,2,3); printf("num =%d\n",num); num = process(mux,2,3); printf("num =%d\n",num); num = process(dive,2,3); printf("num =%d\n",num); return 0; } 14.经常容易混淆的指针概念 第一组： 1 、 int *a[10]; 这是个指针数组，数组 a 中有 10 个整型的指针变量 a[0]~a[9] ，每个元素都是 int * 类型的指针变量 2 、 int (*a)[10]; 数组指针变量，它是个指针变量。它占 4 个字节，存地址编号。 它指向一个数组，它加 1 的话，指向下个数组。 3 、 int **p; 这个是个指针的指针，保存指针变量的地址。 它经常用在保存指针的地址： 常见用法 1 ： int **p int *q; p=&q; 常见用法 2 ： int **p; int *q[10]; 分析： q 是指针数组的名字，是指针数组的首地址，是 q[0] 的地址。 q[0] 是个 int * 类型的指针。 所以 q[0] 指针变量的地址，是 int ** 类型的 p=&q[0]; 等价于 p=q; 例 34： void fun(char**p) { int i; for(i=0;i<3;i++) { printf("%s\n",p[i]);//*（ p+i） } } int main() { char *q[3]={"hello","world","China"}; fun(q); return 0; } 第二组： 1 、 int *f(void); 注意： *f 没有用括号括起来 它是个函数的声明，声明的这个函数返回值为 int * 类型的。 2 、 int (*f)(void); 注意 *f 用括号括起来了， * 修饰 f 说明， f 是个指针变量。 f 是个函数指针变量，存放函数的地址，它指向的函数， 必须有一个 int 型的返回值，没有参数。 15.特殊指针 1 、空类型的指针（void *） char * 类型的指针变量，只能保存 char 型的数据的地址 int * 类型的指针变量，只能保存 int 型的数据的地址 float* 类型的指针变量，只能保存 float 型的数据的地址 void * 难道是指向 void 型的数据吗？ 不是，因为没有 void 类型的变量 void* 通用指针，任何类型的地址都可以给 void* 类型的指针变量赋值。 int *p; void *q; q=p 是可以的，不用强制类型转换 举例： 有个函数叫 memset void * memset(void *s,int c,size_t n); 这个函数的功能是将 s 指向的内存前 n 个字节，全部赋值为 c 。 memset 可以设置字符数组、整型数组、浮点型数组的内容，所以第一个参数，就必须是个通用指针 它的返回值是 s 指向的内存的首地址，可能是不同类型的地址。所以返回值也得是通用指针 注意： void* 类型的指针变量，也是个指针变量，在 32 为系统下，占 4 个字节 2 、NULL 空指针 : char *p=NULL; 咱们可以认为 p 哪里都不指向，也可以认为 p 指向内存编号为 0 的存储单位。 在 p 的四个字节中，存放的是 0x00 00 00 00 一般 NULL 用在给指针变量初始化。 main 函数传参： 例 35： int main(int argc, char *argv[]) #include { int i; printf("argc=%d\n",argc); for(i=0;i { printf("argv[%d]=%s\n",i,argv[i]); } return 0; } 注：资料来自2022最新千锋教育C语言。 欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）