C语言指针必备基础全面覆盖

int main()
{
	int i=3;
	return 0;
}

int main()
{
	int i;
	//int i = 3;//第一种方法
	int *p = &i;//第二种方法
	//这里我们对变量a，取出它的地址，可以使用&操作符。
   //将i的地址存放在p变量中，p就是一个指针变量。
	*p = 3;
	printf("%d\n", i);
	return 0;
}

char  *pc = NULL;//har* 类型的指针是为了存放 char 类型变量的地址。
int   *pi = NULL;//int* 类型的指针是为了存放 int 类型变量的地址。
short *ps = NULL;//short* 类型的指针是为了存放 short 类型变量的地址
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;

int main()

{	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;
	return 0;
}

int main()
{
	int a = 0x11223344;

	char* pc = &a;//int*
	*pc = 0;
	return 0;
}

int main()
{
	int a = 10;
	int * pa=&a;
	char *pc = &a;
	printf("%p\n", pa);
	printf("%p\n", pc);

	printf("%p\n", pa+1);//如果是整型指针int*，+1则跳过4个字节、
	printf("%p\n", pc+1);//char* 指针+1，跳过1个字节
	return 0;
}

#include <stdio.h>
int main()
{ 
 	int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;//通过p中存的随机值作为地址，找到一个空间，这个空间不属于我们当前的程序，就造成了非法访问
//如果非法访问了，p就是野指针
 return 0; }

int main()
{
	int arr[10] = 0;
	int i = 0;
	int * p = arr;

	for (i = 0; i <= 10; i++)//这里循环了11次，当指针指向的范围超出数组arr的范围时，p就是野指针
	{
		*p = 1;
		p++;
	}
	return 0;
}

int* test()
{
	int a = 10;
	return &a;  //int *,生命周期，出来就销毁了
}
int main()
{
	int *p = test();
	//printf("不愧是你\n");//加入这里加了一条语句，下面的值就变了
	printf("%d\n", *p);//编译出10是因为编译器会对值做一次保留。所以能访问到上面函数不一定是对的
	return 0;
}

//规避野指针
int main()
{
	int a = 10;
	int * p = &a;//1、明确初始化，确定指向

	int * p2 = NULL;//NULL本质是0，2、不知道一个指针当前应该指向哪里是，可以初始化位NULL
	//*p2 = 100;//err,对于空指针，是不能直接解引用的

	//如何规避？ 
	if (p2 != NULL)//先判断是不是空指针
	{
		*p2 = 100;//这样才对
	}

}

int main()
{
	float arr[5];
	float *p;
	for (p = &arr[0]; p < &arr[5];)
	{
		*p++ = 0;//对一个指针加1使它指向数组中的下一个元素,把指针指向的内容全部赋值给0
	}
	return 0;
}

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	char ch[5] = { 0 };
	//printf("%d\n", &arr[9] - &ch[0]);//这种算法是错误的

	printf("%d\n", &arr[9] - &arr[0]);//算出的是元素的个数
	printf("%d\n", &arr[0] - &arr[9]);//
	//指针减去指针的前提，是两个指针指向同一块区域
	//指针减去指针，得到数字的绝对值，是指针和指针之间元素的个数

	return 0;
}

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int* p;//定义p位指向整型变量的指针变量
	p = &arr[0];//把a[0]元素的地址赋给指针变量p
	return 0;
}

int main()
{
	int arr[10];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("%d\n", sz);
	printf("%p\n", arr);//数组名就是首元素地址
	//下标法
	printf("%p\n", &arr[0]);
	int* p=&arr[5];//整型地址放在整型指针上，从而让指针跟数组建立联系

	//数组名确实是首元素地址，
	//但是有两个例外
	//1.sizeof(数组名),这里的数组名不是首元素地址，是表示整个数组，计算的是整个数组的大小，单位是字节
	//2.&数组名，拿到的是整个数组的地址

	return 0; 
}

int main()
{
	int arr[10];
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);

	int* p=&arr[0];//整型地址放在整型指针上，从而让指针跟数组建立联系
	//指针法
	for (i = 0; i < sz; i++)
	{
		*(p + i) = i;// p+i 其实计算的是数组 arr 下标为i的地址。
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0; 
}

int main()
{

	int arr[10] = { 0 };
	arr;//数组名
	&arr[0];//取出首元素地址
	&arr;//取出整个数组的地址
	printf("%d\n", &arr[0]);
	printf("%d\n", &arr);
	return 0;
}

int main()
{
	int a = 10;//4byte,向内存申请4个字节
	int* p=&a;//p指向a,称为一级指针

	int* *pp=&p;//pp就是二级指针，pp存放的是一级指针的地址
	* *pp = 20;//需两层解引用	
	printf("%d\n", a);
	//int** * ppp = &pp;//ppp就是三级指针
	return 0;
}

int main()
{
	int arr[10];//整型数组，存放整型的数组就是整型数组
	char ch[5];//字符数组，存放字符的数组就是字符数组
	//指针数组，存放指针的数组就是指针数组
	//int*  整型指针的数组
	//char* 字符指针的数组

	int* parr[5];//整型指针的数组，存放的类型都是int*
	char* pc[6];//字符指针的数组
	return 0;
}

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;

	int * arr[3] = { &a, &b, &c };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d\n",*(arr[i]));
	}

	int *pa = &a;
	int *pb = &b;
	int *pc = &c;
	return 0;
}