C语言之指针一

一个程序程序载入内存，代码数据都有地址，外挂就是调用函数修改数据，函数就是代码。变量就是数据
函数名就是地址
内存地址是连续的，相邻内存单元间的地址差1，可以把内存看成一个平坦的一维空间
内存与CPU读写速度快，容量比较小   ROM

程序：
代码区 数据区 堆栈


指针与指针变量
    指针：一个变量的地址，
指针变量：专门存放变量地址的变量,指针变量的值是地址    

指针类型 ： char*    short*      int*     float*        double*

指针除了首地址以外还有类型，类型决定了指向的数据大小，决定了数据的解析方式，指针的类型必须要和指针的指向类型一致
否则一定会出现偏差，地址相同

&取地址
*根据地址取出内容  ——>     num 等价于 *（&num）
int *p = #        p是指针变量存放num的地址，*p 是对num的解引用，p可以是任何变量的地址
//（int *）是一个指向int类型的指针变量 容纳int变量的地址，p仅仅是一个开始地址，int决定截取多长，里面的数据按照int来解析
//  *p 与int 对称 ，*p 就是int类型数据

指针在函数内部可以改变外部变量


一个exe不可以随意读取另一个exe的内存，
声明指针变量时必须初始化指针变量
无论什么类型的指针变量（32位），大小是固定的，就是4个字节，指针变量是用来存储地址的，什么类型就是按照什么类型来解析
指针的类型决定从地址开始有太长，这段数据如何解析

地址和指针的差别， 地址单单是一个内存区域，指针知道地址从哪里开始哪里结束，不同类型解析长度不同，解析方式并不同    

空指针 NULL  
int *p = NULL; //指针为空，null是0，不指向任何变量

直接访问：按变量地址存取变量值
间接访问：通过存放变量地址的变量去访问变量 （通过指针变量）
%p 按照地址打印，可显示地址的位数

scanf初始化一个指针，可以指明一个指针指向的内存

C语言要改变外部数据只有传地址，Java C++有引用，但是C语言没有

！！！数据当做参数的时候，传递的是指针，改变的是原来的数组，数组数据拷贝非常浪费内存，除了数组以外，都是副本机制，传数组名相当于传指针

//数组作为参数时
#include <stdio.h>
#include <stdlib.h>

//void showa(int a[10]);   形参a相当于一个指针
void showa(int *p)				//一维数组可用如此使用指针
{
	for (int i = 0; i < 10; i++)
		printf("%d\n",p[i]);
}

void  showb(int (*p)[4])		//二维数组，这样使用指针
{
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("%02d  ",**(p + i)+j);  //两个**
		}
		printf("\n");
	} 
	
}

int main()
{
	int a[10] = {1,2,3,4,5,6,7,8,9,10};
	int b[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

	showa(a);
	showb(b);

	system("pause");
}

指向指针的指针（二级指针）
函数的形式参数，除了数组以外，传递任何数据，变量，都会新建一个变量接受传入变量的值，不影响原来的变量

要想改变外部参数，如果是一个数据，传递数据的地址，
如果是一个指针，传递指针的地址，函数内部改变外部指针变量，这就是二级指针的用处
double *p = #   //指向num的指针变量p
double **pp = &p；  //声明二级指针 *pp ，指向 双精度指针变量p的地址
double* 指明是4个字节，*pp 是 double*类型的数据

可以通过用“**”声明一个二级指针，间接改变指针的指向
指针类型尽量一致，类型不一致，会少读取或者多读取

#include <stdio.h>
#include <stdlib.h>
/*
指向指针的指针（二级指针）
函数的形式参数，除了数组以外，传递任何数据，变量，都会新建一个变量接受传入变量的值，不影响原来的变量

要想改变外部参数，如果是一个数据，传递数据的地址，
如果是一个指针，传递指针的地址，函数内部改变外部指针变量，这就是二级指针的用处
double *p = #   //指向num的指针变量p
double **pp = &p；  //声明二级指针 *pp ，指向 双精度指针变量p的地址
可以通过用“**”声明一个二级指针，间接改变指针的指向
*/
int a = 10, b = 11, c = 12;

void change(int *p)			//不能改变p的指向
{
	p = &b;
}

void changep(int **p)		//传递pa的地址才能改变pa的指向,二维指针
{
	*p = &c;
}

int main()
{

	int *pa = &a;			//声明指向a的指针
	int **p = &pa;			//声明指向pa的二级指针
	printf("%d\n",*pa);
	changep(p);
	printf("%d\n", *pa);
	change(p);
	printf("%d\n", *pa);
	system("pause");
}

同类型的指针赋值同一个变量，用于数据通信，三个数据一个改变全部改变
整数和指针最好不要直接运算
*指针就是指针指向的数据类型

#include<stdio.h>
#include<stdlib.h>

//指针的赋值运算，一般就是传递地址，根据地址内容进行操作
//三个数值，有一个变化，全部变化
//地址的比较是没有意义的

//*p++ 和 *(p++)等价，结合方向从自右向左

//数组中，指针之差，可以判断谁的编号在前面，谁的编号在后面
//可以判断两个指针之间相隔多少个元素


int main()
{
	int num = 13;
	int *p = #
	int *pa = p;
	printf("%d  %d   %d\n\n",num,*p,*pa);

	num = 23;	//直接赋值
	printf("%d  %d   %d\n\n", num, *p, *pa);

	*p = 26;	//间接赋值
	printf("%d  %d   %d\n\n", num, *p, *pa);

	*pa = 37;	//间接赋值
	printf("%d  %d   %d\n\n", num, *p, *pa);

	system("pause");
}

指针和二维数组

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
	///int (*p)[4] = a; 二维数组的指针就是一个指向一维数组的指针，元素是确定的
	//a[i][j] = *(*(a+i)+j)	 &a[i][j]=*(a+i)+j
	for (int x = 0; x < 3; x++)
	{
		for (int y = 0; y < 4; y++)
		{
			printf("%2d   %p    ",a[x][y],&a[x][y]);
		}
		printf("\n");
	}

	printf("%p  %p  %p\n",a,a+1,a+2);//a是行指针，指向的数据一行有4个int类型
	printf("%p  %p  %p\n", *a, *a + 1, *a + 2);//*a是一个指向第一行第一个元素的指针
	printf("%p  %p  %p\n", *(a+1), *(a+1) + 1, *(a+1) + 2);//*(a+1)是一个指向第二行第一个元素的指针
	//a[i][j] = *(*(a+i)+j)			&a[i][j]=*(a+i)+j
	//a[i]代表行指针，等价 a+1

	system("pause");
}

int main9()
{
	int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
	printf("%p,%p,%p\n",a,&a,*a);		//地址相同
	//a是一个行指针，指向一个有四个元素的数组，			16
	//&a是一个指向二维数组的指针，二维数组有12个元素，	48
	//*a是一个指向int类型数据的指针						 4
	printf("%d,%d,%d\n", sizeof(*a), sizeof(*&a), sizeof(**a));//16 48 4

	system("pause");
}