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;
/*	int* pa = &a;
	*pa = 0;*/
	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個字節(jié)、
	printf("%p\n", pc+1);//char* 指針+1，跳過1個字節(jié)
	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++)//這里循環(huán)了11次，當指針指向的范圍超出數(shù)組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是因為編譯器會對值做一次保留。所以能訪問到上面函數(shù)不一定是對的
	return 0;
}

//規(guī)避野指針
int main()
{
	int a = 10;
	int * p = &a;//1、明確初始化，確定指向

	int * p2 = NULL;//NULL本質(zhì)是0，2、不知道一個指針當前應該指向哪里是，可以初始化位NULL
	//*p2 = 100;//err,對于空指針，是不能直接解引用的

	//如何規(guī)避？ 
	if (p2 != NULL)//先判斷是不是空指針
	{
		*p2 = 100;//這樣才對
	}

}

int main()
{
	float arr[5];
	float *p;
	for (p = &arr[0]; p < &arr[5];)
	{
		*p++ = 0;//對一個指針加1使它指向數(shù)組中的下一個元素,把指針指向的內(nèi)容全部賦值給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]);//算出的是元素的個數(shù)
	printf("%d\n", &arr[0] - &arr[9]);//
	//指針減去指針的前提，是兩個指針指向同一塊區(qū)域
	//指針減去指針，得到數(shù)字的絕對值，是指針和指針之間元素的個數(shù)

	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);//數(shù)組名就是首元素地址
	//下標法
	printf("%p\n", &arr[0]);
	int* p=&arr[5];//整型地址放在整型指針上，從而讓指針跟數(shù)組建立聯(lián)系

	//數(shù)組名確實是首元素地址，
	//但是有兩個例外
	//1.sizeof(數(shù)組名),這里的數(shù)組名不是首元素地址，是表示整個數(shù)組，計算的是整個數(shù)組的大小，單位是字節(jié)
	//2.&數(shù)組名，拿到的是整個數(shù)組的地址

	return 0; 
}

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

	int* p=&arr[0];//整型地址放在整型指針上，從而讓指針跟數(shù)組建立聯(lián)系
	//指針法
	for (i = 0; i < sz; i++)
	{
		*(p + i) = i;// p+i 其實計算的是數(shù)組 arr 下標為i的地址。
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0; 
}

int main()
{

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

int main()
{
	int a = 10;//4byte,向內(nèi)存申請4個字節(jié)
	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];//整型數(shù)組，存放整型的數(shù)組就是整型數(shù)組
	char ch[5];//字符數(shù)組，存放字符的數(shù)組就是字符數(shù)組
	//指針數(shù)組，存放指針的數(shù)組就是指針數(shù)組
	//int*  整型指針的數(shù)組
	//char* 字符指針的數(shù)組

	int* parr[5];//整型指針的數(shù)組，存放的類型都是int*
	char* pc[6];//字符指針的數(shù)組
	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;
}