重要！！！！！！！！！！！【C语言学习】指针
内存那些事
存储器:存储数据器件外存
外存又叫外部存储器，长期存放数据，掉电不丢失数据
常见的外存设备:硬盘、flash、rom、u盘、光盘、磁带
内存又叫内部存储器，暂时存放数据，掉电数据丢失常见的内存设备:ram、DDR
物理内存:实实在在存在的存储设备
虚拟内存:操作系统虚拟出来的内存,当一个进程被创建的时候，或者程序运行被创建的时候，或者程序运行的时候都会分配虚拟内存，虚拟内存和物理内存之间存在映射关系。
32bit 32根 ------------------------------0x00 00 00 00 ~ 0xff ff ff ff
操作系统会在物理内存和虚拟内存之间做映射。
在32位系统下,每个进程(运行着的程序)的寻址范围是4G, 0x00 00 00 00 ~ 0xff ff ff ff
在写应用程序的，咱们看到的都是虚拟地址。
在运行程序的时候，操作系统会将虚拟内存进行分区。
1.堆
在动态申请内存的时候，在堆里开辟内存。
2.栈
主要存放局部变量(在函数内部，或复合语句内部定义的变量)。
3.静态全局区
1)未初始化的静态全局区
静态变量（定义的时候，前面加 static修饰），或全局变量，没有初始化的，存在此区
2)初始化的静态全局区
全局变量、静态变量，赋过初值的，存放在此区
4代码区
存放咱们的程序代码
5.文字常量区
存放常量的。
内存以字节为单位来存储数据的，哈们可以将程序中的虚拟寻址空间，看成一个很大的一维的字符数组。
本章所接触的内容，涉及到的内存都是虚拟内存，更准确来说是虚拟内存的用户空间
指针的相关概念
操作系统给每个存储单元分配了一个编号，从0x00 00 00 00 ~ 0xff ff ff ff ，这个编号咱们称之为地址。指针就是地址。
指针变量: 是个变量，是个指针变量，即这个变量用来存放一个地址编号
在32位平台下，地址总线是32位的，所以地址是32位编号，所以指针变量是32位的即4个字节。
注意:
无论什么类型的地址，都是存储单元的编号，在32位平台下都是4个字节，即任何类型的指针变量都是4个字节大小
对应类型的指针变量，只能存放对应类型的变量的地址举例:整型的指针变量，只能存放整型变量的地址
扩展：
字符变量char ch; ch占1个字节，它有一个地址编号，这个地址编号就是ch的地址；
整型变量int a; a占4个字节，它占有4个字节的存储单元，有4个地址编号。
指针的定义方法
1 .简单的指针
数据类型 *指针变量名;
在定义指针变量的时候*是用来修饰变量的，说明变量p是个指针变量。
变量名是
2.关于指针的运算符
&取一个变量的地址
*一个指针变量时，起到标识作用，标识定义的是一个指针变量，除此之外其他地方都表示获取一个指针变量保存的地址里面的内容int a=0x0000234f;
int *p; //在定义指针变量的时候*代表修饰的意思·修饰p是个指针变量
p=&a;//把 a的地址给p赋值,&是取地址符
#include <stdio.h>
int main(int argc,char *argv[])
{
//定义一个普通变量
int a=100;
//定义一个指针变量
int *p;
//给指针变量赋值
//将a的地址保存到p中
p=&a;
printf("a=%d %d\n",a,*p);
printf("a=%d %d\n",&a,p);
}
p保存了a的地址，也可以说p指向了a
int num;
num=*p; //注意:在调用的时候*代表取值的意思，*p就相当于p指向的变量，即a所以说num的值为0x234f;
扩展: 如果在一行中定义多个指针变量，每个指针变量前面都需要加*来修饰
int *p,*q;//定义了两个整型的指针变量p和q
int *p,q:/定义了一个整型指针变量p，和整型的变量q
指针大小：不管地址内的空间多大，但是地址编号的长度一样，所以在64位操作系统中，地址都是8个字节（32位 -----4个字节）
#include <stdio.h>
int main(int argc,char *argv[])
{
char *a;
short *b;
int *c;
long *d;
float *e;
double *f;
printf("sizeof(a)=%d\n",sizeof (a));
printf("sizeof(b)=%d\n",sizeof (b));
printf("sizeof(c)=%d\n",sizeof (c));
printf("sizeof(d)=%d\n",sizeof (d));
printf("sizeof(e)=%d\n",sizeof (e));
printf("sizeof(f)=%d\n",sizeof (f));
return 0;
}
指针的分类
按指针指向的数据的类型来分
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、数组指针
指针和变量的关系
指针可以存放变量的地址编号
在程序中，引用变量的方法
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是指针变量
指针就是用来存放变量的地址的。
*+ 指针变量就相当于指针指向的变量
#include <stdio.h>
int main(int argc,char *argv[])
{
int *p1, *p2, temp,a,b;
p1=&a;
p2=&b;
printf("请输入:a b的值:\n");
scanf("%d %d" ,p1, p2);//给p1和p2指向的变量赋值
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;
}
#include <stdio.h>
int main(int argc,char *argv[])
{
int a=0x1234, b=0x5678;
char *p1,*p2;
printf("%#× %#x\n",a,b);
p1=(char *)&a;
p2=(char *)&b;
printf("%#× %#×\n",*p1,*p2);
p1++;
p2++;
printf("%#× %#x\n",*p1,*p2);
return 0;
}
//32位系统下
1:*+指针取值，取几个字节，由指针类型决定的指针为字符指针则取一个字节，
指针为整型指针则取4个字节，指针为double型指针则取8个字节。
2:指针++指向下个对应类型的数据
字符指针++，指向下个字符数据，指针存放的地址编号加1整型指针++,指向下个整型数据，指针存放的地址编号加4
指针和数组元素之间的关系
变量存放在内存中，有地址编号，咱们定义的数组，是多个相同类型的变量的集合， 每个变量都占内存空间，都有地址编号
指针变量当然可以存放数组元素的地址。
int a[10];
//int *p =&a[0];
int *p;
p=&a[0];//指针变量p保存了数组a中第0个元素的地址,即a[0]的地址
2、数组元素的引用方法
方法1:数组名[下标]
int a[10];
a[2]=100;
方法2:指针名加下标
int a[10];
int *p;
p=a；
p[2]=100;//因为p和a等价
补充: c语言规定:数组的名字就是数组的首地址，即第0个元素的地址，是个常量。
注意: p和a的不同，p是指针变量，而a是个常量。所以可以用等号给p赋值，但不能给a赋值。
方法3:通过指针运算加取值的方法来引用数组的元素
int a[10];
int *p ;
*(p+2)=100; //也是可以的，相当于a[2]=100
解释: p是第0个元素的地址，p+2是 a[2]这个元素的地址。对第二个元素的地址取值，即a[2]
#include <stdio.h>
int main(int argc,char *argv[])
{
int a[5]={6,1,2,3,4};
int *p;
p=a;
//只要将数组名赋值给同类型的指针变量，则此时的指针变量与数组名可
//以用相同的方法操作数组
printf( "a[2]=%d\n" ,a[2]);
printf( "p[2]=%d\n",p[2]);
//*(a+n) <==> *(p+n) <==> a[n]<==> p[n]
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);
printf("&a[0]=%p\n",&a[0]);
printf("&a[2]=%p\n",&a[2]);
return 0;
}
指针的运算
1:指针可以加一个整数,往下指几个它指向的变量，结果还是个地址
前提:指针指向数组的时候，加一个整数才有意义
int a[10];
int *p;
p=a;
p+2;//p是a[0]的地址 p+2是&a[2]
假如p保存的地址编号是2000的话，p+2代表的地址编号是2008
char *q;
q=buf
q+2//相当于&buf [2]
**假如:**q中存放的地址编号是2000的话，q+2代表的地址编号是2002
2:两个相同类型指针可以比较大小
前提:只有两个相同类型的指针指向同一个数组的元素的时候，比较大小才有意义指向前面元素的指针小于指向后面元素的指针
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[10];
#include <stdio.h>
//指针的运算
//指针可以加一个整数，往下指几个它指向的变量，结果还是个地址
void test1()
{
int a[0];
int *p,*q;
//q和p间隔8个字节，意味着加一个整数最终移动的字节数与指针变量的类型也有关系
p=a;
q=p+2;
printf("p=%p\n",p);
printf("q=%p\n",q);
return ;
}
//两个相同类型指针可以比较大小
void test2()
{
int a[10];
int *p,*q;
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");
}
}
//两个相同类型的指针可以做减法
void test3()
{
int a[10];
int *p,*q;
p=&a[0];
p=&a[3];
printf("%d\n",q-p);
}
//两个相同类型的指针可以相互赋值
void test4()
{
int a=100;
int *p,*q;
p=&a;
printf("a=%d %d\n",a,*p);
q=p;
printf("*q=%d\n",*q);
*q=999;
printf("a=%d\n",a);
}
int main(int argc,char *argv[])
{
test1();
test2();
test3();
test4();
}
指针数组
1、指针和数组的关系
1:指针可以保存数组元素的地址
2:可以定义一个数组，数组中有若干个相同类型指针变量，这个数组被称为指针数组
指针数组的概念:
指针数组本身是个数组，是个指针数组，是若干个相同类型的指针变量构成的集合**(一般遇到这样的叠词，本质都是后者)**
2、指针数组的定义方法:
类型说明符 *数组名[元素个数];
int * p[10]://定义了一个整型的指针数组p,有10个元素p[0]~p[9],每个元素都是int *类型的变量
int a;
p[1]=&a;
int b[10];
p[2]=&b[3];
p[2]、*(p+2)是等价的，都是指针数组中的第2个元素。
3、指针数组的分类
字符指针数组char *p[10]、
短整型指针数组、
整型的指针数组、
长整型的指针数组
float型的指针数组、
double型的指针数组
结构体指针数组、
函数指针数组
#include <stdio.h>
int main(int argc,char *argv[])
{
//大多数情况，指针数组都用来保存多个字符串
char *name[5]={"AAAAAAAAAA","BBBBBBB","CCCCCCCC","DDDDDDDDD","EEEEEEEEEE"};
int i;
for(i=0;i<5;i++)
{
printf("%s\n",name[i]);
}
return 0;
}
指针的指针–二级指针
指针的指针，即指针的地址，
咱们定义一个指针变量本身指针变量占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都是指针变量，都占8个字节，都存放地址编号，只不过类型不一样而已
#include <stdio.h>
int main(int argc,char *argv[])
{
int a = 100;
//定义一个一级指针
//一级指针用于保存普通变量的地址
int *p = &a ;
//定义一个二级指针
//二级指针用于保存一级指针的地址
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,用来存放多个字符，并且用"1 love C!”给 string 数组初始化，字符串“I love C! ”存放在string中
2、char *str=“I love C!”
定义了一个指针变量str,只能存放字符地址编号，所以说I love C!这个字符串中的字符不能存放在str,指针变量中。str只是存放了字符Ⅰ的地址编号，“I love C!”存放在文字常量区
3、char *str=(char*)malloc(10*sizeof(char));//动态申请了10个字节的存储空间，首地址给str赋值。
strcpy(str,"I love C");//将字符串“I love C!”拷贝到str指向的内存里
总结
字符数组:
在内存(栈、静态全局区)中开辟了一段空间存放字符串
字符串指针:
在文字常量区开辟了一段空间存放字符串，将字符串的首地址付给str
堆:
使用malloc函数在堆区申请空间，将字符串拷贝到堆区
注意:
可修改性:
1.栈和全局区内存中的内容是可修改的
char str[100]="I love C!";
str[0]='y';//正确可以修改的
2．文字常量区里的内容是不可修改的(少使用)
char*str="I love C!";
*str.='y';//错误，I存放在文字常量区，不可修改
3.堆区的内容是可以修改的
char *str=(char*)malloc(10*sizeof(char));
strcpy(str,"I love C");
*st='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或者stropx.
char buf_aver[128];
buf_aver="hel1o 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、二维数组
二维数组，有行，有列。二维数组可以看成有多个一维数组构成的，是多个一维数组的集合，可以认为二维数组的每一个元素是个一维数组。
例:
定义了一个3行5列的一个二维数组。
可以认为二维数组a由3个一维数组构成，每个元素是一个一维数组。
回顾:
数组的名字是数组的首地址，是第0个元素的地址，是个常量，数组名字加1指向下个元素
二维数组a中 ，a+1指向下个元素，即下一个一维数组，即下一行。
#include <stdio.h>
int main(int argc, char *argv[])
{
int a[3][5];
printf("a= %p\n",a);
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个整型元素的数组。
#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个整型元素的一维数组
}
//数组指针的用法
//l
void fun( int(*p)[5],int x ,int y)
{
p[0][1]=101;
}
void test2()
{
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");
}
}
int main(int argc,char *argv[])
{
test1();
test2();
return 0;
}
4、各种数组指针的定义:
(1)、一维数组指针，加1后指向下个一维数组
配合每行有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后指向下个二维数组
配合三维数组来用，三维数组中由若干个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;
5、三维数组指针，加1后指向下个三维数组
p+1跳一个三维数组; 由4个5行6列的二维数组构成的三维数组配合:
6、四维数组指针，加1后指向下个四维数组，以此类推。。 。 。
7、注意:
容易混淆的内容:
指针数组:是个数组,有若干个相同类型的指针构成的集合
数组p有10个int.粪型的指针变量构成，分别是p[0]~p[9]
数组指针:本身是个指针,指向一个数组，加1跳一个数组
Р是个指针，p是个数组指针，p加1指向下个数组，跳10个整形。
指针的指针:
int **p;//p是指针的指针
int *q;
p=&q;
8、数组名字取地址:变成数组指针
一维数组名字取地址,变成一维数组指针，即加1跳一个一维数组
a+1跳一个整型元素，是a[1]的地址
a和 a+1相差一个元素,4个字节
&a就变成了一个一维数组指针,是int(*p)[10]类型的。
(&a)+1和&a相差一个数组即10个元素即40个字节。
#include <stdio.h>
int main(int argc,char *argv[])
{
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的指针类型不同。
int a[4][5];
a+1跳5个整型
(&a)+1跳4行5列(80个字节)·
总结: c语言规定，数组名字取地址，变成了数组指针。加1跳一个数组。
9、数组名字和指针变量的区别:
int a[10];
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]元素的引用。
不同点:
1、a是常量、p是变量
可以用等号’='给p赋值,但是不能用等号给a赋值
2、对a取地址，和对p取地址结果不同
因为a是数组的名字，所以对a取地址结果为数组指针。
p是个指针变量，所以对p取地址（&p）结果为指针的指针。
在二维数组中，行地址取不是取值得意思，而是指针降级的意思，由行地址（数组指针）变成这一行第0个元素的地址。取前后还是指向同一个地方，但是指针的类型不一样了
例21:
#include <stdio.h>
//二维数组的数组名降级问题
//二维数组的数组名默认是一个行指针，加1保存为下一行的首地址
//二维数组的数据名取*，表示地址降级，意味着行指针降级为列指针，加1保存下一个元素的地址
//一维数组的数组名取&，则是地址的升级，将列指针升级为行指针，加一保存下一行元素的首地址
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(int argc,char *argv[])
{
test3()；
}
指针与函数的关系
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);
printf("&a=%p,&b=%p\n",&a,&b);
}
int main(int argc,char *argv[])
{
test1();
}
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。
总结一句话:要想改变主调函数中变量的值,必须传变量的地址,而且还得通过*+地址去赋值,无论这个变量是什么类型的·
void fun(char **q)
{
*q="hello kitty";
}
int main()
{
char *p= "hello world";
fun(&p);
printf("%s\n",p);//结果为:hello kitty
}
注意:
如果实参是一个普通变量，地址传参的话就需要形参是一级指针，
如果实参是一个一级指针，地址传参的话就需要形参是一个二级指针
#include <stdio.h>
//形参
//地址传参：将实参的地址传递给形参，形参对保存的内容进行任何操作,实参的值也会跟着发生变化。
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=%q\n",p,q);
}
void test2()
{
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);
printf("&a=%p,&b=%p\n",&a,&b);
}
int main(int argc,char *argv[])
{
printf("****************************地址传参***********************\n");
test2();
}
(3)、传数组:
给函数传数组的时候，没法一下将数组的内容作为整体传进去。只能传数组的地址。
#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(int argc,char *argv[])
{
test2();
test3();
test4();
}
将数组作为参数传递给函数，不存在复制传参和地址传参，本质都是地址传参，所以在函数内部对数组进行改变,则函数执行完毕后，原本的数组也会改变，因为传递给函数的都是数组的地址
2、指针函数:指针作为函数的返回值
一个函数可以返回整型数据、字符数据、浮点型的数据，也可以返回一个指针。
#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(int argc,char *argv[])
{
test5();
}
修改为静态则为：
3、函数指针：指针保存函数的地址
咱们定义的函数，在运行程序的时候，会将函数的指令加载到内存的代码段。所以函数也有起始地址。
c语言规定:函数的名字就是函数的首地址，即函数的入口地址咱们就可以定义一个指针变量，来存放函数的地址。
这个指针变量就是函数指针变量。
(1):函数指针变量的定义方法
返回值类型(*函数指针变量名)(形参列表);
int max(int x，int y)
{
}
int min(int x，int y)
{
}
可以用P存放这类函数的地址
p=max;
p=min;
调用函数的方法
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);
}
(3):函数指针数组:本质是一个数组，数组里面每一个元素都是一个函数指针。
返回值类型(*函数指针变量名[函数指针的个数])(形参列表);
(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*[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** 类型的
第二组:
注意:f没有用括号括起来
它是个函数的声明，声明的这个函数返回值为int 类型的。
注意*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
这个函数的功能是将s指向的内存前n个字节，全部赋值为c。
memset 可以设置字符数组、整型数组、浮点型数组的内容，所以第一个参数，就必须是个通用指针
它的返回值是s指向的内存的首地址，可能是不同类型的地址。所以返回值也得是通用指针
注意: void*类型的指针变量，也是个指针变量，在32为系统下，占4个字节
2、NULL 空指针:
咱们可以认为p哪里都不指向，也可以认为p指向内存编号为0的存储单位。在p的四个字节中，存放的是0x00 00 00 00
一般NULL用在给指针初始化。
main函数传参
int main(int argc, char "argv[])
argc :是一个int类型的变量，标识命令终端传入的参数的个数
argv :是一个指针数组，用于保存每一个命令终端传入的参数
(QT内无法展示，后面ubuntu系统下详细)