#include <stdio.h>

int main()
{
	int * p; // int *是指針類型，p是對應(yīng)的變量，定義的指針變量p只能用來存儲int類型變量的地址
	int i = 3, j;
	
	p = &i; // 指針變量只能用來存儲對應(yīng)類型變量的地址，所以這里需要對變量i進(jìn)行取地址操作，即&i
	/*
		指針變量p保存了變量i的地址，這樣的話，我們稱：p指向i。通俗地說，通過p可以找到i
		雖然p指向i，但變量p和變量i不是同一個變量
		更準(zhǔn)確地說，修改其中任何一個變量p值不會影響變量i，反之同理
	*/
	
	printf("%d %d\n", *p, i);
	/*
		如果一個指針變量指向某個普通變量，則在指針變量前加上*后就完全等同于指向的普通變量
		換句話說，可以通過指針變量前加*來找到那個指向的普通變量
		以本程序為例，這里的*p就是以p的內(nèi)容為地址的變量
	*/

	j = *p; // *p就是i，所以相當(dāng)于將i的值賦給了j
	printf("i = %d, j = %d\n", i, j); // 輸出結(jié)果為i = 3, j = 3

	return 0;
}

#include <stdio.h>

int main()
{
	int * p;
	int i = 5;
	
	*p = i; // 出錯行
	printf("%d\n", *p);

	return 0;
}

#include <stdio.h>

int main()
{
	int * p;
	int * q;
	int i = 5;
	
	p = &i;
	
	*q = p; // 出錯行
	printf("%d\n", *q);

	return 0;
}

#include <stdio.h>

void f(int i)
{
	i = 99;
}

int main()
{
	int i = 66
	printf("%d\n", i);
	
	f(i);
	printf("%d\n", i);

	return 0;
}

#include <stdio.h>

void f(int * p) // 通過接收地址來確定要修改的變量
{
	*p = 99; // *p就是以p變量的內(nèi)容為地址的變量，也就是要通過該函數(shù)修改的變量
}

int main()
{
	int i = 66
	printf("%d\n", i); // 輸出結(jié)果為66
	
	f(&i); // 由于函數(shù)f的形參是指針變量，故需將變量i的地址發(fā)送過去
	printf("%d\n", i); // 輸出結(jié)果為99

	return 0;
}

void swap(int a, int b)
{
	int t;
	
	t = a;
	a = b;
	b = t;
}

int main()
{	
	int a = 3, b = 5;
	
	swap(a, b);
	
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

void swap(int * p, int * q)
{
	int t;
	
	t = *p;
	*p = *q;
	*q = t;
}

int main()
{	
	int a = 3, b = 5;
	
	swap(&a, &b);
	
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

#include <stdio.h>

void swap(int * p, int * q)
{
	int * t;

	t = p;
	p = q;
	q = t;
}

int main()
{	
	int a = 3, b = 5;
	
	swap(&a, &b);
	
	printf("a = %d, b = %d\n", a, b);

	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];
	int b[5];
	
	a = b; // 錯誤，因為a和b都是常量，所以無法進(jìn)行賦值操作
	a = &a[2]; // 錯誤，因為a是常量，無法對一個常量進(jìn)行賦值操作
	
	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];

	printf("%#X", &a[0]);
	printf("%#X", a); // 與上一行輸出結(jié)果相同，因為一維數(shù)組名就是數(shù)一維組中第一個元素的地址

	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];
	int i;
	
	for (i = 0; i < 5; i++) // 向一維數(shù)組中讀入元素
		scanf("%d", &a[i]); // 通過下標(biāo)引用數(shù)組中的元素

	for (i = 0; i < 5; i++) // 輸出一維數(shù)組的內(nèi)容
		printf("%d ", *(a + i)); // 通過指針引用數(shù)組中的元素

	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];
	int * p = &a[1];
	int * q = &a[4];

	printf("%d\n", q - p); // 輸出結(jié)果為3，證明相隔3個元素

	return 0;
}

#include <stdio.h>

// 自定義的print函數(shù)，其功能是將一維數(shù)組輸出
void print(int a[], int length)
{
	int i;

	for (i = 0; i < length; i++)
		printf("%d ", a[i]); // 也可以寫成printf("%d ", *(a+i));
	
	printf("\n");
}

int main()
{
	int a[5] = { 1, 2, 3, 4, 5 };
	int b[6] = { -1, -2, -3, -4, -5, -6 };
	int c[100] = { 23, 88, 99, 44 };

	print(a, 5);
	print(b, 6);
	print(c, 100);

	return 0;
}

#include <stdio.h>

int main()
{
	char c = 'A';
	int i = 99;
	double x = 66.66;

	char * p = &ch;
	int * q = &i;
	double r = &x;

	printf("%d %d %d\n", sizeof(c), sizeof(i), sizeof(x)); // 輸出結(jié)果為1 4 8
	printf("%d %d %d\n", sizeof(p), sizeof(q), sizeof(r)); // 輸出結(jié)果均為4

	return 0;
}

#include <stdio.h>
#include <malloc.h>

int main()
{
	int i; // 靜態(tài)分配了4個字節(jié)的存儲空間

	int* p = (int*)malloc(4);
	/*
		1.要使用malloc函數(shù)，需添加malloc.h頭文件
		2.malloc函數(shù)只有一個形參，其類型為整型
		3.實參中的4表示請求操作系統(tǒng)為本程序分配4個字節(jié)的動態(tài)存儲空間
		4.malloc的返回值是分配給該系程序的第一個字節(jié)的地址
		5.由于第一個字節(jié)的地址不能確定具體的變量類型，所以需要強(qiáng)制類型轉(zhuǎn)換
		6.第7行代碼一共分配了8個字節(jié)的存儲空間，其中變量p占4個字節(jié)，p指向的空間也占是4個字節(jié)
		7.變量p所占的內(nèi)存是靜態(tài)分配的，p所指向的內(nèi)存是動態(tài)分配的
	*/

	free(p); 
	/*
		free(p)表示釋放p所指向的內(nèi)存
		free函數(shù)只能用來釋放動態(tài)內(nèi)存，不能用來釋放靜態(tài)內(nèi)存，靜態(tài)內(nèi)存只能由操作系統(tǒng)自動釋放
		free(p)只是釋放了p對應(yīng)的內(nèi)存空間，但p的內(nèi)容依舊存在
	*/

	return 0;
}

#include <stdio.h>
#include <malloc.h>

int main()
{
	int a[10]; // 靜態(tài)構(gòu)造一維數(shù)組
	int length;
	int* pArray;
	int i;
	
	scanf("%d", &length);

	pArray = (int*)malloc(sizeof(int) * length);
	/*
		動態(tài)構(gòu)造一維數(shù)組
		該動態(tài)數(shù)組數(shù)組名為pArray，數(shù)組長度為length，數(shù)組中每個元素都是int類型
	*/

	// 對該動態(tài)一維數(shù)組手動賦值
	for (i = 0; i < length; i++)
		scanf("%d", &pArray[i]);

	// 輸出該動態(tài)一維數(shù)組的內(nèi)容
	for (i = 0; i < length; i++)
		printf("%d ", *(pArray + i));
	
	printf("\n");

	free(pArray); // 釋放該動態(tài)數(shù)組

	return 0;
}

#include <stdio.h>

int main()
{
	int i = 10;
	int * p = &i;
	int ** q = &p;
	int *** r = &q;
	
	r = &p; // 錯誤，因為r是int *** 類型，它只能用來存儲int ** 類型變量的地址
	
	printf("i = %d\n", ***r);

	return 0;
}

#include <stdio.h>

void g(int ** q) // 由于p的類型是int *，所以q的類型必須是int **，因為q要用來存放p的地址
{
	
}

void f()
{
	int i;
	int * p;
	
	p = &i;
	
	g(&p); // 要通過g函數(shù)修改p的內(nèi)容，則必須發(fā)送p變量的地址
}

int main()
{
	f();

	return 0;
}

#include <stdio.h>

void f(int** q)
{
	int i = 5;

	*q = &i; // 由于q儲存了p的地址，所以*q就是p，這行代碼實質(zhì)是將i的地址賦給了p
}

int main()
{
	int* p;

	f(&p);

	printf("i = %d\n", *p); // 由于p儲存了i的地址，所以*p就是i

	return 0;
}

#include <stdio.h>

void f(int** q)
{
	*q = (int*)malloc(sizeof(int));
	
	**q = 5;
}

int main()
{
	int* p;

	f(&p);

	printf("%d\n", *p);

	return 0;
}

#include <stdio.h>

void fun(int * p)
{
	int s;
	p = &s;
}

int main()
{
	int * p;

	fun(p);

	return 0;
}

#include <stdio.h>

void fun(int ** p)
{
	int s;
	*p = &s;
}

int main()
{
	int * p;

	fun(&p);

	return 0;
}

#include <stdio.h>
#include <malloc.h>

void fun(int * p)
{
	p = (int *)malloc(sizeof(int));
}

int main()
{
	int * p;

	fun(p);

	return 0;
}

#include <stdio.h>
#include <malloc.h>

void fun(int ** p)
{
	*p = (int *)malloc(4);
}

int main()
{
	int * p;

	fun(&p);

	return 0;
}