九、指针的指针 -- 二级指针
指针的指针，即指针的地址， 咱们定义一个指针变量本身指针变量占4个字节，指针变量也有地址编号
int a;
int *p;
p=&a;
//*p === a
int **q;
q=&p;
//*q === p
//**q === *p === a
int ***m;
m=&q;
//*(*(*m)) === a
注意：
p q m都是指针变量，都占4个字节，都存放地址编号，只不过类型不一样而已
#include <stdio.h>
int main()
{
int a = 100;
//定义一个一级指针
//一级指针用于保存普通变量的地址
int *p = &a;
//定义一个二级指针12 //二级指针用于保存一级指针的地址
int **q = &p;
printf("a = %d %d %d\n", a, *p, **q);
printf("&a = %p %p %p\n", &a, p, *q);
printf("&p = %p %p\n", &p, q);
printf("&q = %p\n", &q);
return 0;
}
运行结果：
十、字符串和指针
字符串的概念：
字符串就是以’\0’结尾的若干的字符的集合
字符串的存储形式： 数组、字符串指针、堆
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、 char *str =(char*)malloc(10*sizeof(char));动态申请了10个字节的存储空间，首地址给str赋值。strcpy(str,"I love C")；//将字符串“Ｉlove C!”拷贝到str指向的内存里
总结：
字符数组：
在内存（栈、静态全局区）中开辟了一段空间存放字符串
字符串指针：
在文字常量区开辟了一段空间存放字符串，将字符串的 首地址 付给str
堆：
使用malloc函数在堆区申请空间，将字符串拷贝到堆区
注意：
可修改性：
1. 栈和全局区内存中的内容是可修改的char str[100]=”I love C!”; str[0]=‘y’;//正确可以修改的2. 文字常量区里的内容是不可修改的char *str=”I love C!”; *str =’y’;//错误，存放在文字常量区，不可修改3. 堆区的内容是可以修改的char *str =(char*)malloc(10*sizeof(char)); strcpy(str,"I love C"); *str=’y’;//正确，可以，因为堆区内容是可修改的
注意：str指针指向的内存能不能被修改，要看str指向哪里。
str指向文字常量区的时候，内存里的内容不可修改str指向栈、堆、静态全局区的时候，内存的内容是可以修改
初始化：
字符数组、指针指向的字符串：定义时直接初始化
char buf_aver[]="hello world";
char *buf_point="hello world";
堆中存放的字符串不能初始化、只能使用strcpy、scanf赋值
char *buf_heap;
buf_heap=(char *)malloc(15);
strcpy(buf_heap,"hello world");
scanf(“%s”,buf_heap);
使用时赋值
字符数组：使用scanf或者strcpy
char buf_aver[128];
buf_aver="hello kitty"; 错误,因为字符数组的名字是个常量
strcpy(buf_aver,"hello kitty"); 正确
scanf("%s",buf_aver); 正确指向字符串的指针：
char *buf_point;
buf_point="hello kitty"; 正确,buf_point指向另一个字符串
strcpy(buf_point,"hello kitty"); 错误，只读,能不能复制字符串到buf_piont指向的内存里，取决于
buf_point指向哪里。十一、数组指针
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;
}运行结果：
2、数组指针的概念：
本身是个指针，指向一个数组，加1跳一个数组，即指向下个数组。数组指针的作用就是可以保存二维数组的首地址
例：
#include <stdio.h>
int main() {
int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
int (*ptr)[3]; // 声明一个数组指针，指向包含3个元素的整型数组
ptr = arr; // 将二维数组的首地址赋给数组指针
printf("二维数组的首地址：%p\n", arr);
printf("二维数组的第二行首地址：%p\n"，arr+1);
printf("通过数组指针访问二维数组的第一个元素：%d\n", **ptr); // 输出二维数组的第一个元素
printf("通过数组指针访问二维数组的第二行第一个元素：%p\n"，**(ptr+1));
return 0;
}
运行结果：
3、数组指针的定义方法
：
指向的数组的类型（*指针变量名）[指向的数组的元素个数] int (*p)[5];//定义了一个数组指针变量p，p指向的是整型的有5个元素的数组p+1 往下指5个整型，跳过一个有5个整型元素的数组。
#include<stdio.h>
void test1()
{
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个整型元素的一维数组
}
int main()
{
test1();
return 0;
}
运行结果：
数组指针的用法
#include<stdio.h>
//数组指针的用法
//可以将二维数组的首地址传递到另一个函数里面，此时函数的形参就需要定义为数组指针
void fun(int(*p)[5],int x,int y)
{
p[0][1]=101;
}
void test2()
{
int i,j;
int a[3][5] = {0};
fun(a,3,5);
for(i=0;i<3;i++)
{
for(j=0;j<5;j++)
{
printf("%d ",a[i][j]);
}
printf("\n");
}
}
int main()
{
test2();
return 0;
}
运行结果：
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;
（3）、三维数组指针，加1后指向下个三维数组
int(*p)[4][5][6];
p+1跳一个三维数组；
什么样的三维数组啊？
由4个5行6列的二维数组构成的三维数组
配合：
int a[7][4][5][6];
（4）、四维数组指针，加1后指向下个四维数组，以此类推。
5、容易混淆的内容：
指针 数组 ：是个数组，有若干个相同类型的指针构成的集合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;
6、
数组名字取地址：变成
数组指针
一维数组名字取地址，变成一维数组指针，即加1跳一个一维数组
int a[10];
a+1 跳一个整型元素，是a[1]的地址
a和a+1 相差一个元素，4个字节
&a就变成了一个一维数组指针,是 int(*p)[10]类型的。
(&a) +1 和&a相差一个数组即10个元素即40个字节。
7、数组名字和指针变量的区别：
int a[10];
int *p;
p=a;
相同点：
a是数组的名字，是a[0]的地址，p=a即p也保存了a[0]的地址，即a和p都指向a[0]，所以在引用数组元素的时候，a和p等价
不同点：
1、 a是常量、p是变量可以用等号’=’给p赋值，但是不能用等号给a赋值2、 对a取地址，和对p取地址结果不同因为a是数组的名字，所以对a取地址结果为数组指针。p是个指针变量，所以对p取地址（&p）结果为指针的指针。
8、多维数组中指针的转换：
在二维数组中，行地址 取 * 不是取值得意思，而是指针降级的意思，由行地址（数组指针）变成这一行第0个元素的地址。取*前后还是指向同一个地方，但是指针的类型不一样了
//二维数组的数组名降级问题
//二维数组的数组名默认是一个行指针，加1保存下一行的首地址
//二维数组的数据名取*，表示地址的降级，意味着行指针降级为列指针，加1保存下一个元素的地址
//一维数组的数组名默认是一个列指针，加1保存下一个元素的地址
//一维数组的数组名取&，则是地址的升级，将列指针升级为行指针，加1保存下一行元素的首地址
#include<stdio.h>
void test3()
{
int a[3][5];
printf("a=%p\n",a);
printf("a +1=%p\n",a+1);
printf("*a =%p\n",*a);// *a变成了第0行第0列元素的地址
printf("(*a)+1 =%p\n",(*a)+1 ); //结果为第0行第1列元素的地址
}
int main()
{
test3();
return 0;
}
运行结果：
十二、指针与函数的关系
12.1 指针作为函数的参数
可以给一个函数传一个 整型、字符型、浮点型的数据，也可以 给函数传一个地址。函数的传参方式：复制传参、地址传参、全局传参（几乎用不到）
12.1.1 复制传参 -- 传数值
#include <stdio.h>
//函数的传参方式之复制传参：将实参的值传递给形参，不管形参怎么改变，跟实参都没有关系
void myfun1(int a, int b)
{
int temp;
temp = a;
a = b;
b = temp;
printf("in fun: a = %d, b = %d\n", a, b);
printf("&a = %p, &b = %p\n", &a, &b);
}
void test1()
{
int a = 100, b = 20;
printf("before fun: a = %d, b = %d\n", a, b);
printf("&a = %p, &b = %p\n", &a, &b);
myfun1(a, b);
printf("after fun: a = %d, b = %d\n", a, b);
}
int main()
{
test1();
return 0;
}
运行结果：
12.1.2 地址传参 -- 传地址
//函数的传参方式之地址传参：将实参的地址传递给形参，形参对保存的地址的内容
//进行任何操作，实参的值也会跟着改变
void myfun2(int *p, int *q)
{
int temp;
temp = *p;
*p = *q;
*q = temp;
printf("in fun: *p = %d, *q = %d\n", *p, *q);
printf("p = %p, q = %p\n", p, q);
}
void test1()
{
int a = 100, b = 20;
printf("before fun: a = %d, b = %d\n", a, b);
printf("&a = %p, &b = %p\n", &a, &b);
myfun2(&a, &b);
printf("after fun: a = %d, b = %d\n", a, b);
}
int main()
{
test1();
return 0;
}
运行结果：
注意：如果实参是一个普通变量，地址传参的话就需要形参是一级指针，如果实参是一个一级指针，地址传参的话就需要形参是一个二级指针， 以此类推
12.2 传数组
将数组作为参数传递给函数，不存在复制传参和地址传参，本质都是地址传参，所以在函数内部对数组进行改变，则函数执行完毕后，原本的数组也会改变，因为传递给函数的都是数组的地
#include<stdio.h>
//传一维数组
//void fun1(int p[])//形式1
void fun1(int *p)//形式2(常用)
{
printf("%d\n",p[2]);
printf("%d\n",*(p+3));
}
void test2()
{
int a[10]={1,2,3,4,5,6,7,8};
fun1(a);
}
//传二维数组
//void fun2( int p[][4] )//形式1
void fun2( int (*p)[4] )//形式2：通过数组指针
{
//p[x][y] <==> *(*(p + x) + y)
printf("%d\n", p[0][2]);
printf("%d\n", *(*(p+1) + 2));
}
void test3()
{
int a[2][4] = {1, 2, 3, 4,5, 6, 7, 8};
fun2(a);
}
//传指针数组
void fun3(char **q)
{
int i;
for(i=0;i<3;i++)
{
printf("%s\n",q[i]);
}
}
void test4()
{
char *p[3]={"hello","world","kitty"};
fun3(p);
}
int main()
{
test2();
test3();
test4();
return 0;
}
运行结果：
12.3 指针函数 -- 指针作为函数的返回值
指针函数本质是一个函数，只不过函数的返回值是一个指针
#include<stdio.h>
//指针函数：指针作为函数的返回值
char *fun4()
{
//栈区开辟的空间会随着当前代码段的结束而释放空间
//char str[100]="hello world";
//静态区的空间不会随着当前代码段的结束而释放空间
static char str[100]="hello world";
return str;
}
void test5()
{
char *p;
p = fun4();
printf("p = %s\n", p);
}
int main()
{
test5();
return 0;
}
运行结果：
12.4 函数指针 - 指针保存函数的地址
定义的函数，在运行程序的时候，会将函数的指令加载到内存的代码段，所以函数也有起始地址。c语言规定：函数的名字就是函数的首地址，即函数的入口地址，就可以定义一个指针变量， 来存放函数的地址，这个指针变量就是函数指针变量。
12.4.1 函数指针变量的定义方法
返回值类型 (*函数指针变量名 )( 形参列表 );
int (*p)(int,int);//定义了一个函数指针变量p,p指向的函数
//必须有一个整型的返回值，有两个整型参数。
int max(int x,int y) { }
int min(int x,int y) { }
//可以用这个p存放这类函数的地址。
p=max; p=min;12.4.2 调用函数的方法
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);
}
12.4.3 函数指针数组
函数指针数组：本质是一个数组，数组里面的每一个元素都是一个函数指针返回值类型 (*函数指针变量名[函数指针的个数])(形参列表);int(*p[10])(int,int);定义了一个函数指针数组，有10个元素p[0] ~p[9]，每个元素都是函数指针变量， 指向的函数，必须有整型的返回值，两个整型参数。
12.4.4 函数指针最常用的地方
函数指针最常用的地方在于将一个函数作为参数传递给另一个函数的时候要使用函数指针将一个函数作为参数传递给另一个函数，将这个函数称之为回调函数
#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 a,int b)
{
int ret;
ret = (*p)(a,b);
return ret;
}
int main(int argc, char *argv[])
{
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;
}
运行结果：
十三、经常容易混淆的指针
第一组：
1、 int *a[10];
这是个指针数组，数组a中有10个整型的指针变量a[0]~a[9]
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 **类型的
第二组：
1、int *f(void);
注意：*f没有用括号括起来
它是个函数的声明，声明的这个函数返回值为int *类型的。
2、int (*f)(void);
注意*f用括号括起来了，*修饰f说明，f是个指针变量。f是个函数指针变量，存放函数的地址，它指向的函数，
必须有一个int型的返回值，没有参数。
十四、特殊指针
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函数传参
int
main(
int
argc,
char
*argv[])
argc：是一个int类型的变量，标识命令终端传入的参数的个数argv：是一个指针数组，用于保存每一个命令终端传入的参数
#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;
}运行结果：
1410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
