C語言學習之指標知識總結

#include <stdio.h>

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

	j = *p; // *p就是i，所以相當於將i的值賦給了j
	printf("i = %d, j = %dn", i, j); // 輸出結果為i = 3, j = 3

	return 0;
}

#include <stdio.h>

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

	return 0;
}

#include <stdio.h>

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

	return 0;
}

#include <stdio.h>

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

int main()
{
	int i = 66
	printf("%dn", i);
	
	f(i);
	printf("%dn", i);

	return 0;
}

#include <stdio.h>

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

int main()
{
	int i = 66
	printf("%dn", i); // 輸出結果為66
	
	f(&i); // 由於函數f的形參是指標變數，故需將變數i的地址傳送過去
	printf("%dn", i); // 輸出結果為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 = %dn", 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 = %dn", 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 = %dn", a, b);

	return 0;
}

#include <stdio.h>

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

#include <stdio.h>

int main()
{
	int a[5];

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

	return 0;
}

#include <stdio.h>

int main()
{
	int a[5];
	int i;
	
	for (i = 0; i < 5; i++) // 向一維陣列中讀入元素
		scanf("%d", &a[i]); // 通過下標參照陣列中的元素

	for (i = 0; i < 5; i++) // 輸出一維陣列的內容
		printf("%d ", *(a + i)); // 通過指標參照陣列中的元素

	return 0;
}

#include <stdio.h>

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

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

	return 0;
}

#include <stdio.h>

// 自定義的print函數，其功能是將一維陣列輸出
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 %dn", sizeof(c), sizeof(i), sizeof(x)); // 輸出結果為1 4 8
	printf("%d %d %dn", sizeof(p), sizeof(q), sizeof(r)); // 輸出結果均為4

	return 0;
}

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

int main()
{
	int i; // 靜態分配了4個位元組的儲存空間

	int* p = (int*)malloc(4);
	/*
		1.要使用malloc函數，需新增malloc.h標頭檔案
		2.malloc函數只有一個形參，其型別為整型
		3.實參中的4表示請求作業系統為本程式分配4個位元組的動態儲存空間
		4.malloc的返回值是分配給該系程式的第一個位元組的地址
		5.由於第一個位元組的地址不能確定具體的變數型別，所以需要強制型別轉換
		6.第7行程式碼一共分配了8個位元組的儲存空間，其中變數p佔4個位元組，p指向的空間也佔是4個位元組
		7.變數p所佔的記憶體是靜態分配的，p所指向的記憶體是動態分配的
	*/

	free(p); 
	/*
		free(p)表示釋放p所指向的記憶體
		free函數只能用來釋放動態記憶體，不能用來釋放靜態記憶體，靜態記憶體只能由作業系統自動釋放
		free(p)只是釋放了p對應的記憶體空間，但p的內容依舊存在
	*/

	return 0;
}

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

int main()
{
	int a[10]; // 靜態構造一維陣列
	int length;
	int* pArray;
	int i;
	
	scanf("%d", &length);

	pArray = (int*)malloc(sizeof(int) * length);
	/*
		動態構造一維陣列
		該動態陣列陣列名為pArray，陣列長度為length，陣列中每個元素都是int型別
	*/

	// 對該動態一維陣列手動賦值
	for (i = 0; i < length; i++)
		scanf("%d", &pArray[i]);

	// 輸出該動態一維陣列的內容
	for (i = 0; i < length; i++)
		printf("%d ", *(pArray + i));
	
	printf("n");

	free(pArray); // 釋放該動態陣列

	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 = %dn", ***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函數修改p的內容，則必須傳送p變數的地址
}

int main()
{
	f();

	return 0;
}

#include <stdio.h>

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

	*q = &i; // 由於q儲存了p的地址，所以*q就是p，這行程式碼實質是將i的地址賦給了p
}

int main()
{
	int* p;

	f(&p);

	printf("i = %dn", *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("%dn", *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;
}