6.1 指针
6.1.1关于内存那点事
存储器: 存储数据器件外存
外存又叫外部存储器]长期存放数据，掉电不丢失数据常见的外存设备:硬盘、flash、rom、u 盘、光盘、磁带
内存
内存又叫内部存储器，暂时存放数据，掉电数据丢失
常见的内存设备: ram、DDR（内存条）
物理内存:实实在在存在的存储设备
虚拟内存:操作系统虚拟出来的内存
32bit 32 根寻址总线
0x00 00 00 00
Oxff ff ff ff
在 32 位系统下，每个进程(运行着的程序) 的寻址范围是 4G.0x00 00 00 00~0xff ff ff ff在写应用程序的，咱们看到的都是虚拟地址
6.1.2指针的概念
系统给虚拟内存的每个存储单元分配了一个编号，从 0x00 00 00 00 ~0xff ff ff ff 这个编号咱们称之为地址
指针就是地址
指针变量:是个变量，是个指针变量，即这个变量用来存放一个地址编号在 32 位平台下，地址总线是 32 位的，所以地址是 32 位编号，所以指针变量是 32 位的即 4个字节
指针变量:是个变量，是个指针变量，即这个变量用来存放一个地址编号在 32 位平台下，地址总线是 32 位的，所以地址是 32 位编号，所以指针变量是32 位的即 4个字节
注意: 1:
无论什么类型的地址，都是存储单元的编号，在 32 位平台下都是 4 个字节，即任何类型的指针变量都是 4 个字节大小.
2: 对应类型的指针变量，只能存放对应类型的变量的地址举例:整型的指针变量，只能存放整型变量的地址
扩展:
字符变量 char ch=“b’:ch 占1个字节，它有一个地址编号，这个地址编号就是 ch 的地址整型变量 inta=0x123456 78: a 占4 个字节，它占有4个字节的存储单元，有4 个地址编号。
提醒：指针是地址，存储指针的变量叫指针变量，和其他存储int float等变量是一样的。只不过存储类型不一样。
6.1.3指针变量得定义方法
1.简单得指针变量
数据类型 * 指针变量名；
int * p;//定义了一个指针变量p；
在 定义指针变量得时候 * 是用来修饰变量的，说明变量p是个指针变量
变量名是p
2.关于指针的运算符
&取地址，*取值
例如：
int a=0x1234abcd;
int*p;//在定义指针变量的时候*代表修饰的意思，修饰p是个指针变量
p=&a;//把a的地址给p赋值&是取地址符。
p保存了a的地址，也就是说p指向了a
p和a的关系分析：a的值是0x1234abcd,假如a的地址是：0xbf e8 98 68
那么p存放得是a的地址编号
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
#include<stdio.h>
int main()
{
int a = 100, b = 200;
int* p_1, * p_2 = &b;//表示该变量的类型是一个指针变量，指针变量名是p_1而不是*p_1
p_1 = &a;//p_1先定义后赋值；在定义的时候没有赋初值，p_2赋了初值
printf("a=%d\n", a);
printf("*p_1=%d\n",* p_1);
printf("b=%d\n", b);
printf("*p_2=%d\n",* p_2);
return 0;
}
注意：
在定义p_1的时候，因为是一个局部变量，局部变量没有赋初值，他的值是随机的，p_1指向哪里不一定，所以p_1就是野指针
3.指针大小
在32位系统下，所以类型的指针都是4个字节
#include<stdio.h>
int main()
{
char* p1;
short int* p2;
int* p3;
long int* p4;
float* p5;
double* p6;
printf("sizeof(p1)=%d\n",sizeof(p1));
printf("sizeof(p2)=%d\n",sizeof(p2));
printf("sizeof(p3)=%d\n",sizeof(p3));
printf("sizeof(p4)=%d\n", sizeof(p4));
printf("sizeof(p5)=%d\n", sizeof(p5));
printf("sizeof(p6)=%d\n", sizeof(p6));
return 0;
}
#include<stdio.h>
int main()
{
int a = 0x1234abcd;
int* p;
p = &a;
printf("&a=%p\n",&a);
printf("p=%p\n",p);
return 0;
}
6.1.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个字节。
指针只能存放对应类型的变量的地址编号；
6.1.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是指针变量
指针就是用来存放变量的地址的
*+指针变量 就相当于指针指向的变量
#include<stdio.h>
int main()
{
int* p1,*p2,temp,a, b;
p1 = &a;
p2 = &b;
printf("请输入a,b的值\n");
scanf_s("%d%d", p1, p2);//给p1和p2p指向的变量赋值
temp = *p1;//用p1指向的变量（a）给temp赋值
*p1 = *p2;//用p2指向的变量（b)给p1指向的变量（a）赋值
*p2 = temp;//temp给p2指向的变量（b）赋值
printf("a=%d b=%d\n",a,b);
printf("*p1=%d *p2=%d\n" ,*p1, *p2);
return 0;
}
扩展：
对应类型的指针，只能保存对应类型数据的地址
如果想让不同类型的指针相互赋值的时候，需要强制类型转换
void*p;
#include<stdio.h>
int main()
{
int a = 0x12345678, b = 0xabcdef66;
char* p1,* p2;
printf("%0x %0x\n", a,b);
p1 = (char*)&a;
p2 = (char*)&b;
printf("%0x %0x\n",*p1,*p2);
p1++;
p2++;
printf("%0x %0x\n" ,*p1, *p2);
return 0;
}
注意：
1:*+指针取值，取几个字节，由指针类型决定的指针为字符指针则取一个字节，指针为整形指针则取4个字节，指针为double型指针则取8个字节
2:指针++指向下个对应类型的数据
字符指针++，指向下个字符数据，指针存放的地址编号加1；
整型指针++，指向下个整形数据，指针存放的地址编号加4；
6.1.6指针和数组元素之间的关系
1.关系
变量存放在内存中，有地址编号，咱们定义的数组，是多个相同类型的变量集合，
每个变量都占内存空间，都有地址编号
指针变量当然可以存放数组元素的地址。
2. 数组元素的引用方法
方法一：数组名[下标]
int a[5];
int*p;
p=a;
p[2]=100;//因为p和a等价 a[2]=100;
补充:C语言规定：数组的名字就是数组的首地址，即第0个元素的地址，就是&a[0],是个常量。
注意：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赋值。
#include<stdio.h>
int main()
{
int a[5] = {0,1,2,3,4};
int* p;
p = a;
printf("a[2]=%d\n", a[2]);
printf("p[2]=%d\n", p[2]);
printf("*(p+2)=%d\n",*(p+2));
printf("*(a+2)=%d\n", *(a+2));
printf("p=%p\n", p);
printf("p+2=%p\n", p+2);
return 0;
}
3.指针的运算
1：指针可以加一个整数，往下指几个它指向的变量，结果还是个地址
前提：指针指向数组元素的时候，加一个整数才有意义。
#include<stdio.h>
int main()
{
char buf[5];
char* q;
q = buf;
printf("q=%p\n", q);
printf("q+2=%p\n", q + 2);
return 0;
}
2.两个相同类型指针可以比较大小
前提：只有两个相同类型的指针指向同一个数组元素的时候，比较大小才有意义
指向前面元素的指针 小于 指向后面的元素指针
#include<stdio.h>
int main()
{
int a[10];
int* p, * q, n;//如果在一行定义多个指针变量的，每个变量名前面加*
//上边一行定义了两个指针p和q，定义一个整型的变量n
p = &a[1];
q = &a[6];
if (p < q)
{
printf("p<q\n");
}
else if (p > q)
{
printf("p>q\n");
}
else
{
printf("p==q\n");
}
return 0;
}
p<q
3.两个想同类型的指针可以做减法
前提：必须是两个相同类型的指针指向同一个数组的元素的时候，做减法才有意义
做减法的结果是，两个指针指向的中间有多少个元素；
#include<stdio.h>
int main()
{
int a[10];
int* p, * q;
p = &a[0];
q = &a[3];
printf("%d\n", q - p);
return 0;
}
输出3；中间隔多少个元素不是12字节
4：两个相同类型的指针可以相互赋值
注意：只有相同类型的指针才可以相互赋值（void*类型的除外）
int*p；
int*q；
int a;
p=&a;//保存a的地址，p指向了变量a
q=p;//用p给q赋值，q也保存了a的地址，指向a
注意：
如果类型不相同的指针要相互赋值，必须进行强制类型转换
注意：
C语言规定数组的名字，就是数组的首地址，就是数组第0个元素地址
int*p;
int a[10];
p=a;
p=&a[0];这两种赋值的方法是等价的；
6.1.7指针数组
1.指针和数组的关系
1：指针可以保存数组元素的地址
2：可以定义一个数组，数组中有若干个相同类型指针变量，这个数组被称为指针数组
指针数组的概念：
指针数组本身是个数组，是个指针数组，是若干个相同类型的指针变量构成的集合
2.指针数组的定义变量
类型说明符*数组名[元素个数]；
int *p;//定义了一个整数的指针数组p，有5个元素p[]~p[5],
每个元素都是int*类型的变量
int a;
p[0]=&a;
int b[10];
p[1]=&b[5];
p[2],*(p+2)是等价的，都是指针数组中的第2个元素
#include<stdio.h>
int main()
{
int* p[5];
int a = 100;
int b[10] = { 1,2,3,4,5,6,7,8,9,0 };
printf("sizeof(p)=%d\n", sizeof(p));
p[0] = &a;
p[1] = &b[2];
printf("*p[1]=%d\n",* p[1]);
printf("p[0]=%p\n", p[0]);
printf("&a=%p\n", &a);
printf("*p[0]=%d\n", *p);
return 0;
}
#include<stdio.h>
int main()
{
char* name[5] = { "hello","china","beijing","project","computer" };
int i;
for (i = 0; i < 5; i++)
{
printf("%s\n", name[i]);
}
return 0;
}
注意;name[0] name[1],name[2],name[3],name[4]而分别是char*类型的指针变量，分别存放在一个地址编号。
3.指针数组的分类
字符指针数组char*p[10],短整形指针数组，整型的指针数组，长整型的指针的数组
flaot型的指针数组，double型的指针数组
结构体指针数组，函数指针数组
6.1.8 指针的指针
指针的指针，即指针的地址
咱们定义一个指针变量本身指针变量占4个字节，指针变量也有地址编号。
int a=0x123456789;
假如：a的地址是0x00002000
int *p;
p=&a;
则p中存放的是a的地址编号即0x00002000
因为p也占4个字节内存，也有它自己的地址编号，即指针变量的地址，即之指针的指针。
假如：指针变量p的地址编号是0x00003000,这个地址编号就是指针的地址
我们定义一个变量存放p的地址编号，这个变量就是指针的指针
int* *q;
q=&p;//保存了p的地址，也可以说q指向了p
则q里存放的就是0x00003000
int***m;
m=&q;
p q m都是指针变量 都占4个字节，都存放地址编号，只不过类型不一样而已
#include<stdio.h>
int main()
{
int a = 0x12345678;
int* p;
int** q;
int*** m;
p = &a;
printf("p=%p\n", p);
printf("&a=%p\n", &a);
q=&p;
printf("&p=%p\n",&p);
printf("q=%p\n",q);
m=&q;
printf("&q=%p\n",&q);
printf("m=%p\n",m);
printf("*p=%x\n",*p);
printf("**q=%x\n",**q);
printf("***m=%x\n",***m);
return 0;
}
6.1.9字符串和指针
字符串的概念
字符串就是以‘0’结尾的若干的字符的集合：比如："helloworld".
字符串的地址，是第一个字符的地址。如：字符串“helloword”的地址，其实是字符串中字符‘h’的地址。
我们可以定义一个字符指针变量保存字符串的地址，比如：char*s="helloworld";
字符串的存储形式：数组，文字常量区，堆
1.字符串存放在数组中
其实就是内存（栈，静态全局区中开辟了一段空间存放字符串。
char string[100]="I LOVE C!"
定义了一个字符数组string，用来存放多个字符，并且用“I LOVE YOU!”给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!");//将字符串“I LOVE C!”拷贝到str指向的内存里
字符串的可修改性
字符串内容是否可以修改，取决于字符串存放在哪里
1.存放在数组中的字符串的内容是可修改的
char str[100]="I LOVE C!";
str[0]='y';//正确可以修改的
注：数组没有用const修饰
#include<stdio.h>
int main()
{
char str[100] = "I LOVE C!";
printf("str=%s\n", str);
str[0] = 'y';
printf("str=%s\n", str);
return 0;
}
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 修饰) 、堆区的时候，它指向内存的内容是可以修改
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main()
{
char* str;
str = (char*)malloc(20);
strcpy(str, "I love c!");
printf("str=%s\n", str);
*str = 'y';
printf("str=%s\n", str);
}
字符串存储得三种形式
初始化:
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";
6.1.10数组指针
1.二维数组
二维数组，有行，有列。二维数组可以看成有多个一维数组构成的，是多个一维数组的集合，可以认为二维数组的每一个元素是个一维数组。
例:
int a[3][5];
定义了一个3 行 5 列的一个二维数组。
可以认为二维数组 a由3 个一维数组构成，每个元素是一个一维数组；
回顾:
数组的名字是数组的首地址，是第 0个元素的地址，是个常量，数组名字加 1 指向下个元素
二维数组 a中 ，a+1 指向下个元素，即下一个一维数组，即下一行。
#include<stdio.h>
int main()
{
int a[3][5];
printf("a=%p\n", a);
printf("a+1=%p\n",a+1);
return 0;
}
十进制20个字节 用程序员计算器计算；
2.数组指针的概念:
本身是个指针，指向一个数组，加1跳一个数组，即指向下个数组。
3.数组指针的定义方法
指向的数组的类型 (*指针变量名)[指向的数组的元素个数]
int(*p)[5]://定义了一个数组指针变量 p，p 指向的是整型的有 5 个元素的数组
p+1 往下指 5 个整型，跳过一个有 5 个整型元素的数组。
#include<stdio.h>
int main()
{
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;
}
定义指针数组的时候需要与二维数组列数一样
#include<stdio.h>
void fun(int(*p)[5],int x,int y)
{
p[1][2]=100;
}
int main()
{
int a[3][5] = {
{1,2,3,4,5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15},
};
printf("a[1][2]=%d\n", a[1][2]);
fun(a, 3, 5);
printf("a[1][2]=%d\n", a[1][2]);
return 0;
}
4、各种数组指针的定义:
(1)、一维数组指针，加 1 后指向下个一维数组
int(*p)[5] ;//int *p[5];两个不一样后面指针数组
配合每行有 5个 int 型元素的二维数组来用
int a[3][5]
int b[4][5]
int c[5][5]
int d[6][5]
....
p=a；
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;
#include <stdio.h>
int main()
{
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[o] ~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 个字节。
#include <stdio.h>
int main()
{
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[o]的地址。
&a 变成了数组指针，加 1跳一个 10 个元素的整型一维数组
在运行程序时，大家会发现 a 和&a 所代表的地址编号是一样的，即他们指向同一个存储单元，但是 a和&a 的指针类型不同。
#include <stdio.h>
int main()
{
int a [4][5];
printf("a=%p\n", a);//int (*p) [5];
printf("a+1 = % p\n",a+1);
printf(" & a = % p\n",&a); //int(*p)[4][5];
printf("&a + 1 = % p\n",& a+ 1);
return 0;
}
总结:c 语言规定，数组名字取地址，变成了数组指针。加 1 跳一个数组。
9. 数组名字和指针变量的区别:
int a[5]:
int *p;
p=a;
相同点:
a 是数组的名字，是 a[0]的地址，p=a 即 p 保存了 a0]的地址，即 a和p 都指向 a[0]，所以在引用数组元素的时候，a和p等价
引用数组元素回顾:
a[2]、*(a+2)、p[2]、*(p+2) 都是对数组 a 中 a[2]元素的引用。
#include <stdio.h>
int main()
{
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;
#include<stdio.h>
int main()
{
int a[5] = {0, 1, 2, 3, 4 };
int* p;
p = a;
p = &a[3]; printf("*p=%d\n", *p);
return 0;
}
1、&p 是指针的指针为 int **类型，结果为 0x00003000，&p +l，往后指向一个 int* 类型的指针地址编号差 4
2、&a 结果是数组指针，为 int(* )[5]类型，结果还是 0x00002000，&a +1.往后指一个数组(有5个整型元素的一维数组)，地址编号差 20
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[5];
int* p;
p = a;
printf("a=%p\n", a);
printf("&a=%p\n", &a);//int (* )[5]
printf("p=%p\n",p);
printf("&p=%p\n", &p); //int **
printf("&p +1=%p\n", &p + 1);
return 0;
}
10.数组指针取*
数组指针取 *，并不是取值的意思，而是指针的类型发生变化;
一维数组指针取*，结果为它指向的一维数组第 0个元素的地址，它们还是指向同一个地方。
二维数组指针取 *，结果为一维数组指针，它们还是指向同一个地方。
三维数组指针取*，结果为二维数组指针，它们还是指向同一个地方。
多维以此类推
#include <stdio.h>
int main()
{
int a[3][5];
int(*p)[5];
p = a;
printf("a=%p\n",a);//a 是一维数组指针，指向第 0 个一维数组，即第 0行
printf(" a+1 = % p\n", a+1);
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+1 = %p\n", p+1);
printf("*p=%p\n",*p);//*p 是第 0行第 0个元素的地址，即 &a[O][0]
printf("*p +1=%p\n",*p + 1);//*p +1 是第 0 行第1个元的地址，即&a[O][1]
printf("&a[0][0]=%p\n", &a[0][0]);
return 0;
}
6.1.11指针和函数的关系
6.1.11.1 指针作为函数的参数
咱们可以给一个函数传一个 整型、字符型、浮点型的数据，也可以
给函数传一个地址。
例:
int num；
scanf("%d",&num)；
函数传参:
(1)、传数值:
#include<stdio.h>
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);
return 0;
}
实参:调用函数时传的参数。
形参:定义被调函数时，函数名后边括号里的数据
结论:给被调函数传数值，只能改变被调函数形参的值，不能改变主调函数实参的值
（2)、传地址:
#include<stdio.h>
void swap(int* pl, int* p2)
{
int temp;
temp = *pl;
*pl= *p2;
*p2 = temp;
}
int main()
{
int a = 10, b = 20;
swap(&a, &b);
printf("a=%d,b=%d\n", a, b);
return 0;
}
结论:调用函数的时候传变量的地址，在被调函数中通过*+地址来改变主调函数中的变量的值
#include<stdio.h>
void swap(int* pl, int* p2)
{
int* p;
p = pl;
pl = p2;
p2 = p;
}
int main()
{
int a = 10, b = 20;
swap(&a, &b);
printf("a = % d, b = % d\n", a, b);
return 0;
}
总结:要想改变主调函数中变量的值， 必须传变量的地址，而且还得通过*+地址 去赋值。
#include<stdio.h>
void fun(char* q)
{
q = "hello kitty";
}
int main()
{
char* p = "hello world";
fun(p);
printf("p=%s\n", p);
return 0;
}
#include<stdio.h>
void fun(char** q)
{
*q = "hello kitty";
}
int main()
{
char* p = "hello world";
fun(&p);
printf("p=%s\n", p);
return 0;
}
总结一句话:要想改变主调函数中变量的值，必须传变量的地址，而且还得通过*+地址 去赋值，无论这个变量是什么类型的。
(3) 传数组:
给函数传数组的时候，没法一下将数组的内容作为整体传进去。
只能传数组名进去，数组名就是数组的首地址，即只能把数组的地址传进去。
例如：传一维数组的地址
#include<stdio.h>
void fun(int* p)//int p[]也行
{
printf("p[2]=%d\n", p[2]);
*(p + 3) = 100;
}
int main()
{
int a[10] = { 1,2,3,4, 5,6, 7,8,9,0 };
fun(a);
printf("a[3]=%d\n", a[3]);
return 0;
}
传二维数组的地址
#include<stdio.h>
//void fun （int p[][4],int x,int y）
void fun(int(*p)[4], int x, int y)
{
int i, j;
printf("p[1][2]=%d\n", p[1][2]);
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d", p[i][j]);
}
printf("\n");
}
}
int main()
{
int a[3][4] =
{
{1,2,3,4},
{5, 6, 7, 8},
{9, 0, 10, 11 }
};
fun(a, 3, 4);
printf("a[0][1]=%d\n", a[0][1]);
return 0;
}
传指针数组
指针的指针
#include<stdio.h>
void fun(char** q, int x)
{
int i;
for (i = 0; i < x; i++)
{
printf("q[%d]=%s\n", i, q[i]);
}
}
int main()
{
char* p[3] = { "hello","world","china"}; //p[0] p[1] p[2]是 char*char*
fun(p,3);//p 就是 &p[0]，是char*
return 0;
}
6.1.11.2 指针作为函数的返回值
一个函数可以返回整型数据，字符数据，浮点数据，也可以返回一个指针
#include<stdio.h>
char* fun(void)
{
static char str[100] = "hello world";
// char*str="hello world";
return str;
}
int main()
{
char* p;
p= fun();
printf("p=%s\n", p);
return 0;
}
//总结:返回地址的时候，地址指向的内存的内容不能释放如果返回的指针指向的内容已经被释放了，返回这个地址，也没有意义了。
返回静态局部数组的地址
返回文字常量区得分字符串的地址
原因是文字常量去的内容，一直存在
返回堆内存的地址
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
char* fun(void)
{
char str;
str = (char*)malloc(100);
strcy_s(str, "hello world");
return str;
}
int main()
{
char* p;
p= fun();
printf("p=%s\n", p);
free(p);
return 0;
}
原因是堆区的内容一直存在，知到free才释放
总结：返回的地址，地址指向的内存的内容得存在，返回的地址有意义。
6.1.11.3 指针保存函的地址
1.函数指针的概念
咱们定义的函数，在运行程序的时候，会将函数的指令加载到内存的代码段。所以函数也有起始地址。
c 语言规定:函数的名字就是函数的首地址，即函数的入口地址
咱们就可以定义一个指针变量，来存放函数的地址。
这个指针变量就是函数指针变量。
2.函数指针指针用处:
函数指针用来保存函数的入口地址。
在项目开发中，我们经常需要编写或者调用带函数指针参数的函数。比如Linux 系统中创建多线程的函数，它有个参数就是函数指针，接收线程函数的入口地址，即线程创线程成功后，新的任务执行线程函数。
int pthread_create(pthread_t *thread, const pthread _attr_t *attr,
void *(*start routine) (void *). void *arg);
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)；
}
#include<stdio.h>
int max(int x, int y)
{
int tmp;
if (x > y)
tmp = x;
else
tmp = y;
}
int min(int x, int y)
{
int tmp;
if (x < y)
tmp = x;
else
tmp = y;
}
int main()
{
int(*p)(int,int);
int num;
num = max(10, 20);
printf("num=%d\n", num);
p = min;
num = (*p)(10, 20);//等价于num=min(10,20);
printf("num=%d\n", num);
return 0;
}
2.可以通过函数指针变量去调用
int max(int x,int y)
{
}
int main（）
{
}
5.函数指针数组
概念:由若干个相同类型的函数指针变量构成的集合，在内存中连续的顺序存储.函数指针数组是个数组，它的每个元素都是一个函数指针变量。函数指针数组的定义:
类型(*数组名[元素个数])(形参列表)
int(*p[5])(int,int);
定义了一个函数指针数组，有 5 个元素 p[0] ~p[4]，每个元素都是函数指针变量,每个函数指针变量指向的函数，必须有整型的返回值，两个整型参数。
6.函数指针应用举例
#include<stdio.h>
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 dive(int x, int y)
{
return x / y;
}
int process(int(*p)(int, int), int x, int y)
{
int ret;
ret = (*p)(x, y);
return ret;
}
int main()
{
int num;
num = process(add,10,20);
printf("num=%d\n", num);
num = process(mux, 10, 20);
printf("num=%d\n",num);
return 0;
}
6.1.12经常容易混的指针概念
第一组:
1、 int *a[10];
这是个指针数组，数组 a 中有 10 个整型的指针变量
a[0]~a[9],每个元素都是int*类型的指针变量
2、int (*a)[10];
数组指针变量，它是个指针变量。它占 4 个字节，存地址编号。它指向一个数组，它加 1 的话，指向下个数组。
3.int **p;
这个是个指针的指针，保存指针变量的地址。它经常用在保存指针的地址:
常见用法 1:
int *p;
p=&q;
常见用法 2:
int **p;
int *q[10];
分析:q 是指针数组的名字，是指针数组的首地址，是 q[o]的地址。q[0]是个 int *类型的指针。所以 q[O]指针变量的地址，是 int **类型的
p=&q[0];等价与p=q;
第二组:
1、int *f(void)；
注意:*f 没有用括号括起来
它是个函数的声明，声明的这个函数返回值为 int *类型的。
2、int (*f)(void);
注意*f用括号括起来了，*修饰 f说明，f是个指针变量。f是个函数指针变量，存放函数的地址，它指向的函数，必须有一个 int 型的返回值，没有参数。
6.1.13特殊指针
1、空类型的指针(void *)
char*类型的指针变量，只能保存 char 型的数据的地址
int*类型的指针变量，只能保存 int 型的数据的地址
float* 类型的指针变量，只能保存 foat 型的数据的地址
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函数传参：
#include<stdio.h>
int main(int argc,char* argv[])
{
int i;
printf("argc=%d\n", argc);
for (i = 0; i < argc; i++)
{
printf("argv[%d]=%s\n", i, argv[i]);
}
return 0;
}
751
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
