指针
1、内存载入过程：
（1）程序要进行的操作对应的代码被装载到代码区。
（2）全局和静态数据等装载到数据区
（3）开辟堆栈，供临变量等使用
可见，内存中的数据是多种多样的，既可以是操作，也可以是数据，都被存储在一个个的内存小格子中，每个小格子存储8个二进制位。
变量是对程序中数据存储空间的抽象
指针：一个变量的地址
指针变量：专门存放变量地址的变量叫~
变量是指其值可以变化的量。计算机中，指令代码、数据都存储于内存中。变量也需要存储在内存中。在计算机中，每个变量都被分配了一块内存空间，在这些空间里存储的就是变量的值。变量之所以可以变化，就是这个存储空间可以存储不同的数值。存储空间里的值变化，则变量对应的值也变化。同一个时间，内存空间里只能保存一份值，新值冲掉了原来的旧值。每个内存单元都有编号，这些是内存的地址。
#include <stdio.h>
// 内存地址是内存当中存储数据的一个标识，并不是数据本身，通过内存地址可以找到内存当中存储的数据。
// *是根据地址取出内容， &是取地址
// 一个程序载入内存中，代码和数据都有地址，函数就是代码，变量就是数据；代码查看要回汇编，而数据可以直接查看
//外挂就是调用函数，修改数据
//内存容量比较小，读写速度比较快，但断电就没有了,cpu不能直接访问硬盘的数据
//实际上内存是把8个8个bit排成1组， 每1组成为1个单位， 大小是1byte(字节）， cpu每一次只能访问1个byte
//而不能单独去访问具体的1个小格子(bit). 1个byte字节就是内存的最小的IO单位.
// 内存就是一栋大楼, 而内存里每1个字节就是大楼的每个房间, 而内存地址就是房间的门牌号码了.
//32位的计算机，在32位操作系统中, 内存的地址就是32位的2进制数, 那么2^32到底是多少个？ 2^32 = 4 * 1024(G) * 1024(M) * 1024(K) = 4294967296 , 就是4G 啊, 而每1个地址对应1个1个字节，
// 容量就是1byte， 所以2^32个地址就总共能对应应4GB 的内存容量啊， 这里的B指的是byte 字节啊。
// 其地址空间为32位，采用32位地址编码，一个小房间就是4个字节，32位
//为什么32位的计算机只支持4G内存？
// 4G=4*1024M = 4*1024*1024KB =4*1024*1024*1024 byte = 2^32 byte =4GB
// 0000 0000 0000 0000 0000 0000 0000 00000
// 00 00 00 00
// 1111 1111 1111 1111 1111 1111 1111 1111
// ff ff ff ff
//注意：内存地址不等于内存，一个内存地址对应一个字节大小的内存
void main1(){
printf("%x \n",main1); //函数名就是函数代码块的首地址
int n =4; //变量就是对内存空间的数据的抽象
printf("%x \n",&n); //&n是一个变量的地址，也是一个指针，指向num
printf("%d \n",*(&n)); // *是根据地址取出内容
int num =100;
int *p = # //P是一个指针变量，可以指向任何变量的地址 定义时：*p前面有类型限制 ，引用时：*p没有类型限制
// 用num访问100是直接访问，用*p访问是间接访问;
//p只是存储 num 变量的起始地址，前面的int确定它往后读取多长，也就是读取4个字节，按照int类型解析数据
// 定义时， (int *) 是一个指向int类型的指针变量，容纳 int 变量的地址
//所谓指针，指的是“储存的内容是地址的量”，两个要点：一、指针是个量，对应着一块内存区域，二，指针存储的信息是某个内存单元的地址
// 指针是地址，地址不是指针。
//地址0x567DFd只是一个纯粹的地址，而指针是一个可以存储地址的变量，它的值可以变化，而且有int类型
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void changeNum(int *p){ //定义一个int类型的指针变量，用于接收变量的地址
*p = 111; //根据地址改变其数据
}
void main2(){
int num=100;
int *p = # //定义指针时必须初始化， p是变量，而&num是常量
// p = num;
// 编译时：此句就相当于把100当做一个16进制的地址赋值给指针p，也就是p指向的内存地址为 0X00000064 （100的16进制）地址空间，此为系统空间，运行时：会发生访问冲突
changeNum(&num); // 等价于 changeNum(p); C语言要改变外部变量只能传地址，java和c++可以用引用传值，c语言没有引用
printf("%d\n",num);
num=100;
// p num p = # 把num的地址编号赋给了p所指向的内存空间 value：61fe4c，p自己的内存空间也有编号 addr：61fe40
// addr （&）: 61fe40 61fe4c
// value （*）: 61fe4c 0x64(100)
printf("num=%x\n",num); // 变量是对程序中数据存储空间的抽象 num指向的值为0x64
printf("&num=%x\n",&num); // & 取出num的地址编号 61fe4c
printf("p=%x\n",p); // p是一个指针变量，存储的是num的地址编号 61fe4c
printf("*p=%x\n",*p); // * 表示取出 指针 p 地址 61fe4c 所指向的值 0x64
printf("&(*p)=%x\n",&(*p)); // *p是0x64，取64的地址
printf("&p=%x\n",&p); // &取出指针 p 的地址编号61fe40，而指针 p 地址中的值又是 num 变量内存地址（编号）,61fe4c。
printf("*(&p)=%x\n",*(&p)); // &取出指针 p 的地址61fe40 ，再取出此地址61fe40中内容p，即： *(&p) = 61fe4c =&num =p
printf("p=%p\n",p); // 按地址打印，0x0061fe4c
// 结论： &和* 两个在一起，会相互抵消其作用
/*
num=0x64
&num=61fe4c
p=61fe4c
*p=0x64
&(*p)=61fe4c
&p=61fe40
*(&p)=61fe4c
p=0x0061fe4c
*/
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//数组作为函数参数时，传递的是指针，会改变原来的数组内容，因为数组拷贝非常浪费内存
//除数组以外其他参数的传递都是副本机制，新建一个变量的副本
//改变外部变量
//函数参数如果是一个数据，传递的是数据的地址（指针）
//函数参数如果是一个指针，传递的是指针的地址（指针的指针，二级指针）
void go(int a[5]){
printf("%d\n", sizeof(a)); //8 传过来的是数组a的地址，大小固定，8个字节
a[0] =9;
printf("a[0] in go :%d\n",a[0]);
}
void goPointer(int *p){ //从main函数传进来的p1和p不是同一个指针，新建一个指针变量p，存入p1的副本地址，即p=p1,
printf("p address in goPointer before :%x\n",p);//61fe44
int num =10;
p = # //改变p的指向，不影响p1的指向，还是61fe44
printf("p address in goPointer after :%x\n",p);//p address in goPointer after :61fdec
}
void changePointer(double **pp, int num ){ //从main函数传进来的pp是二级指针的地址，也就是一级指针内存编号
printf("*pp address in changePointer before :%x\n",*pp);//
*pp = # //改变*pp的指向,也就是改变一级指针的内存地址编号
printf("*pp address in changePointer after :%x\n",*pp);//p address in goPointer after :61fdec
}
void main(){
int num =100;
int *p1 =# //定义了int类型的指针，虽然类型变量是int类型，但指针存放num变量的地址，固定为8个字节
double dNum =10;
double *p2 =&dNum; //定义了一个一级指针p2，虽然类型是double基本数据类型，但指针存放dNum变量的地址，所以固定是8个字节
double *p3 =&p2; //错误，p1内存地址编号32位的平台是固定4个字节的长度，直接把地址赋值给double类型8个字节的指针会报错 //initialization of 'double *' from incompatible pointer type 'int **'
double **pp = &p2; //等价于(double *) *pp = &p2, pp指向了一个double * 类型的变量，存储的是一个double类型的一级指针（地址），也就是&p2
// 二级指针 => 一级指针 => 基本数据类型
// 定义时: int **pp => int *p => int pp
// 引用时: pp => *p => **pp
float *p4; //float类型的指针
printf("%d,%d,%d,%d,%d,%d\n", sizeof(p1), sizeof(p2), sizeof(p3), sizeof(p4), sizeof(double *),sizeof(int *)); // output 8,8,8,8,8,8
//指针只是一个存储指针的变量，大小固定是8个字节，与类型无关，与平台有关,32位的平台是4个字节
int a[5] ={1,2,3,4,5};
printf("%d\n", sizeof(a)); // 20
go(a); //数组名代表数组的首地址
printf("a[0] in main :%d\n",a[0]); //9
goPointer(p1); //p1的地址传给了goPointer函数
printf("p1 address in main :%x\n",p1);//p1 address in main :61fe44
//测试二维指针的函数传递
int n1 =20, n2=30;
printf("*pp = %x, p2 = %x\n",*pp,p2); //*pp = 61fe20, p2 = 61fe20 *p就是p2的内存地址编号，所以两者一样, 一级指针
changePointer(pp,n1); //*pp address in changePointer before :61fe20
//*pp address in changePointer after :61fec8
printf(" *pp address in main :%x\n",*pp);// pp address in main :61fec8 change之后把二级指针所指向的值，也就是一级指针的内存编号改变了 20 => c8
changePointer(&p2,n2); //*pp address in changePointer before :61fdc8 &p2，就相当于pp的存储内容，也就是一级指针的内存编号
//*pp address in changePointer after :61fdc8
printf(" p2 address in main :%x\n",p2);//p2 address in main :61fdc8
}
1、指针存储的是变量的首地址，指明了从哪里开始，从哪里结束由类型来指定，类型指定长度和如何解析数据，在32位系统中是用4个字节存储指针地址，不用与指针所指向的值混淆。
2、指针运算
一级指针
1、函数改变外部变量的时候，需要用到指针，传入某个值的地址（间接修改）
2、跨进程改变变量（外挂）
3、数组会直接改变其值
4、可以存储数组的首地址，数组下标法遍历（可能会越界），指针法遍历
5、作为函数返回值，返回地址，但一定不能返回指向栈的地址
6、一级指针指向字符串的首地址，间接访问结构体，共用体
7、创建堆上的动态数组，访问数组中的数据
#include <stdio.h>
#define getName(x) #x //#x意思是把getName(x)替换成 "x" 字符串
#define mutiply(x) (x)*(x) //宏定义函数
#define add(x,y) (x)*(y) //宏定义函数
void main(){
//传递main的地址，打印函数名，可以使用宏定义
printf("%s\n",getName(main)); //main
printf("%d\n",mutiply(2)); //4
printf("%d\n",add(2,3)); //6
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// * 和 ++ 优先级深究
void main7(){
int a[3] = {1,4,9};
int *pa = a; //*p等价于int类型，p等价于int *类型 指针要在定义的时候初始化
printf("%d, %p\n",*pa,pa); //1, 0061FEC0
*pa++; //说明++的优先级比*高
printf("%d, %p\n",*pa,pa); //4, 0061FEC4
int b[3] = {1,4,9};
int *pb = a;
printf("%d, %p\n",*pb,pb); //1, 0061FEBC
++*pb; //++要与pb接触才有优先级，实际上是 ++(*p)
printf("%d, %p\n",*pb,pb); // 2, 0061FEBC
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
swap(int *p1, int *p2) //这里会新建一个p1，p2的指针变量存储pointer_1和pointer_2的地址，交换了p1和p2的地址后，和pointer_1，pointer_2没有关系
{ int *p; //p在定义的时候没有初始化，可能会出现垃圾数据
p=p1;
p1=p2;
p2=p;
}
void main()
{ int a,b;
int *pointer_1,*pointer_2;
scanf("%d,%d",&a,&b);
pointer_1=&a; pointer_2=&b;
if(a<b) swap(pointer_1,pointer_2); //swap只是交换新建变量p1和p2的地址，和pointer_1，pointer_2没有关系
printf("%d,%d",*pointer_1,*pointer_2);
}
