C語言玩轉指標之指標的高階玩法

2021-10-30 16:01:01

前言

指標第一篇，萬人瀏覽：

指標的主題，我們在初級階段的《指標》章節已經接觸過了，我們知道了指標的概念：

1.指標就是個變數，用來存放地址，地址唯一標識一塊記憶體空間。
2. 指標的大小是固定的4/8個位元組（32位元平臺/64位元平臺）。
3. 指標是有型別，指標的型別決定了指標的±整數的步長，指標解除參照操作的時候的許可權。
4. 指標的運算

這個章節，我們繼續探討指標的高階主題

一、字元指標

在指標的型別中我們知道有一種指標型別為字元指標 char* 。

思考以下程式碼，pc和p分別指向何方？

int main()
{
	char ch = 'www';
	char *pc = &ch;//pc是指向一個字元變數的
	const char* p = "hello boy";//"hello boy"是一個常數字串
	//上面表示式的作用是：把常數字串「hello bit」的第一個字元h的地址賦給p(指向首字元地址)
	return 0;
}

【注意】

程式碼 char* pstr = 「hello bit.」; 特別容易讓同學以為是把字串 hello boy 放到字元指標
p裡了，但是/本質是把字串 hello boy首字元的地址放到了p中。

思考下面程式碼，輸出的是什麼？

int main()
{
	char str1[] = "hello boy.";
	char str2[] = "hello boy.";
	//兩個字元陣列，獨立開闢空間。
	//陣列名是陣列首元素地址
	char *str3 = "hello boy.";
	char *str4 = "hello boy.";
	//二者都是指向常數字串，（常數字串，是不能修改的）
	//二者指向的是同一個地址

	if (str1 == str2)//比較兩個陣列的地址，肯定不相等
		printf("str1 and str2 are samen");
	else
		printf("str1 and str2 are not samen");

	if (str3 == str4)
		printf("str3 and str4 are samen");
	else
		printf("str3 and str4 are not samen");

	return 0;
}

所以結果如下圖

二、指標陣列和陣列指標

指標陣列是指標還是陣列？

答案是：陣列。

陣列指標是指標還是陣列？

答案是：指標。

舉個例子：

int *p1[5];  //指標陣列
int (*p2)[5];  //陣列指標

二者形式很相似，那麼我們如何區分呢？

1.指標陣列

【指標陣列】

首先它是一個陣列，陣列的元素都是指標，陣列佔多少個位元組由陣列本身決定。它是「儲存指標的陣列」的簡稱。

指標陣列是陣列元素為指標的陣列(例如 int *p[5],定義了p[0],p[1],p[2],p[3],p[4]五個指標)，其本質為陣列。

int *p[5];

這裡涉及到一個優先順序的問題。

我們知道陣列下標的優先順序比取值運運算元的優先順序高。所以，p先被定義為具有5個元素的陣列。它的型別是int*，所以它是指向整型變數的指標。

【結論】指標陣列是一個陣列，每個陣列元素存放一個指標變數。

指標陣列如何初始化呢？

int main()
{
	//char *arr[5];//arr是存放字元指標的陣列
	//int * arr2[4];//arr2是存放整型指標的陣列

	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	                //int* int* int* int*
	int * arr2[4] = { &a, &b, &c, &d };//arr2就是整型指標的陣列
	printf("%dn", *arr2[0]);//取出第一個地址的內容
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%dn", *(arr2[i]));
	}
	return 0;
}

陣列指標中&a，&b,&c,&d分別指向10，20，30，40

大家有沒發現，如果這樣定義的話，會有些繁瑣。

所以我們可以採用以下的方法：

int main()
{
	const char* arr[5] = { "abcedf", "bcedfg", "hehe" ,"hhh","zhangsan"};
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%sn", arr[i]);
	}
	return 0;
}

2.陣列指標

2.1.陣列指標是什麼？

【陣列指標】

首先它是一個指標，它指向一個陣列。在 32 位系統下永遠是佔 4 個位元組，
至於它指向的陣列佔多少位元組，不知道。它是「指向陣列的指標」的簡稱。

陣列指標是指向陣列地址的指標，其本質為指標。

int (*p)[5];

在上面程式碼中，圓括號和陣列下標位於同一優先順序佇列，所以從左到右執行。

因此，p先被定義為一個指標變數，後邊[5]表示的是一個具有5個元素的陣列，p指向的就是這個陣列。

由於指標變數的型別事實上就是它所指向的元素的型別，所以這個int定義陣列元素的型別為整型。

通過下面一個例子來加深理解

int main()
{
	int a = 10;
	int*pi=&a;//整型的地址存放到整型指標中
	char ch = 'w';
	char* pc=&ch;//字元的地址存放在字元指標中


	int arr[10] = { 0 };
	int*p = arr;//arr-是陣列首元素的地址

	//int* parr[10]; //這樣寫是陣列
	int (*parr)[10]=&arr;//取出的是陣列的地址,應該存放到陣列指標中
	return 0;
}

那麼我們如何進行初始化呢？

我們在學習指標的時候，是將指標指向陣列名，因為陣列名是陣列首元素地址，知道了第一個元素的地址，後面的元素就可知道。如下：

int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int *p = arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%dn", *(p + i));
	}
	return 0;
}

所以，上面的指標p是一個指向整型變數的指標，它並不是指向陣列的指標。而陣列指標，才是指向陣列的指標。

所以，在初始化的時候，應該將陣列的地址傳遞給陣列指標，而不是傳遞陣列第一個元素的地址。它們值雖然相同，但含義不一樣。

int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int (*p)[] = &arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%dn", *(*p + i));
	}
	return 0;
}

2.2.&陣列名和陣列名的區別

我們以arr和&arr來舉例說明：

a,&a 的值是一樣的。
但意思不一樣，
a 是陣列首元素的首地址，也就是 a[0]的首地址。
&a 是陣列的首地址，表示的是陣列的地址。

例如：

int main()
{
	int arr[5] = { 0 };
	printf("%pn", arr);
	printf("%pn", &arr);
	return 0;
}

可以看到，它們的值是一樣的。

但是，如果它們+1呢？

如下：

#include <stdio.h>
int main()
{
 int arr[5] = { 0 };
 printf("arr = %pn", arr);
 printf("&arr= %pn", &arr);
 //+1看看
 printf("arr+1 = %pn", arr+1);
 printf("&arr+1= %pn", &arr+1);
 return 0; }

可以看到，+1後的結果就不一樣了。

那麼為什麼呢？

a 是陣列首元素的首地址，也就是 a[0]的首地址。
&a 是陣列的首地址。
a+1 是陣列下一元素的首地址，即 a[1]的首地址。
&a+1 是下一個陣列的首地址。

2.3.陣列指標的使用

陣列指標指向的是陣列，存放的是陣列的地址

那怎麼使用，舉個例子：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int (*p)[10] = &arr;//把陣列arr的地址賦值給陣列指標變數p
    //這裡*先與p結合，再與 [ ] 結合，由於上面定義的陣列是int型別，所以取地址的型別也是int型別。
    return 0; 
}

來看下面程式碼，思考我們如何利用陣列指標列印我們想要的結果呢？

void print(int (*parr)[10], int sz)//傳上來地址，用陣列指標接受
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
	//以下3種方式都能列印
		//printf("%d ", parr[0][i]);//把一維陣列當成二維陣列，[0]表示第一行，[i]表示遍歷元素
		//printf("%d ", (*(parr + 0))[i]);//*(parr + 0)解除參照首元素地址
		printf("%d ", (*parr)[i]);//(*parr) 相當於 parr指向的陣列的陣列名
	}
}
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(&arr, sz);//&arr把陣列的首元素地址傳上去函數

	return 0;
}

三、陣列引數與指標引數

我們都知道引數分為形參和實參。

形參是指宣告或定義函數時的引數
實參是在呼叫函數時主調函數傳遞過來的實際值。

1.一維陣列引數

一維陣列傳參是怎樣的呢?

我們先來看一個例子：

請大家思考一下，下面能否傳參成功？

#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int *arr)//ok?
{}
void test2(int *arr[20])//ok?
{}
void test2(int **arr)//ok?
{}
int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0};
 test(arr);
 test2(arr2);
 }

2.二維陣列引數

二維陣列的傳參跟一維陣列類似。

舉個例子：

同樣思考能否傳參成功？

void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//總結：二維陣列傳參，函數形參的設計只能省略第一個[]的數位。
//因為對一個二維陣列，可以不知道有多少行，但是必須知道一行多少元素。
//這樣才方便運算。
void test(int *arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int (*arr)[5])//ok？
{}
void test(int **arr)//ok？
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

3.一級指標傳參

首先，用一級指標傳參，那就用一級指標接收

#include <stdio.h>
void print(int *p, int sz) //一級指標接收int* p
{
	 int i = 0;
	 for(i=0; i<sz; i++)
 {
	 printf("%dn", *(p+i));
 }
}
int main()
{
	 int arr[10] = {1,2,3,4,5,6,7,8,9};
	 int *p = arr;
	 int sz = sizeof(arr)/sizeof(arr[0]);
 //一級指標p，傳給函數
	 print(p, sz);
	 return 0;
 }

那如果我們用一級指標接收傳過來的引數，我們的引數可以是什麼樣的形式呢？

void test(int *p)//可以接收什麼？
{}
int main()
{
	int a = 10;
	int* p1 = &a;
	int arr[10] = {0};
//怎樣傳給函數？
	return 0;
}

其實我們可以有下面的方式：

void test(int *p)
{}
int main()
{
	int a = 10;
	int* p1 = &a;
	int arr[10] = {0};

	test(&a);//傳地址上去可以
	test(arr);//傳個陣列名過去可以
	test(p1);//傳個指標也可以
	test(NULL);//傳空指標也行，考慮清楚，因為傳空指標就是傳0，並且空指標不能解除參照，不支援存取空間

	return 0;
}

4.二級指標傳參

如果是二級指標怎麼傳參呢？

同樣的，我們可以有下面的方法。

void test(int **ppa)
{}

int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	
	int* arr[5];

	test(ppa);
	test(&pa);
	test(arr);

	return 0;
}

四、函數指標

函數指標是是什麼？

我們說，陣列指標就是陣列的指標。是指向陣列的指標。

同理

函數指標就是函數的指標。它是一個指標，指向一個函數

我們思考一下下面三個程式碼：

char * (*fun1)(char * p1,char * p2);
char * *fun2(char * p1,char * p2);
char * fun3(char * p1,char * p2);

什麼意思？

char * (*fun1)(char * p1,char * p2);


char *fun2(char * p1,char * p2);
//fun2是函數名，p1，p2 是引數，其型別為 char *型，函數的返回值為 char *型別。

char ** fun3(char * p1,char * p2);
//與 第二個表示式相比，唯一不同的就是函數的返回值型別為 char**，是個二級指標。

那麼第一個程式碼是什麼意思？

這裡 fun1 不是什麼函數名，而是一個

指標變數，它指向一個函數。這個函數有兩個指標型別的引數，函數的返回值也是一個指標。

那麼我們如何使用函數指標呢？

#include <stdio.h>
#include <string.h>
char * fun(char * p1, char * p2)
{
	int i = 0;
	i = strcmp(p1, p2);
	if (0 == i)
	{
		return p1;
	}
	else
	{
		return p2;
	}
}
int main()
{
	char * (*pf)(char * p1, char * p2);
	pf = &fun;
	(*pf) ("aa", "bb");
	return 0;
}

我們使用指標的時候，需要通過鑰匙（「*」）來取其指向的記憶體裡面的值，函數指標使用也如此。通過用(*pf)取出存在這個地址上的函數，然後呼叫它。

給函數指標賦值時，可以用&fun 或直接用函數名 fun。這是因為函數名被編譯之後其實就是一個地址，所以這裡兩種用法沒有本質的差別。

接下來看一下下面這個程式碼什麼意思？

(*(void(*) ())0)(

第一步：void(*) ()，可以明白這是一個函數指標型別。這個函數沒有引數，沒有返回值。

第二步：(void(*) ())0，這是將 0 強制轉換為函數指標型別，0 是一個地址，也就是說一個函數存在首地址為 0 的一段區域內。

第三步：((void() ())0)，這是取 0 地址開始的一段記憶體裡面的內容，其內容就是儲存在首地址為 0 的一段區域內的函數。

第四步：((void() ())0)()，這是函數呼叫。

五、函數指標陣列

把函數的地址存到一個陣列中，那這個陣列就叫函數指標陣列

char * (*pf[3])(char * p);//一個函數指標陣列，pf為陣列名，型別是char*(*)()
//pf先於[3]結合，說明是一個陣列，陣列記憶體儲了3個指向函數的指標
//指標再與*結合，說明是一個函數指標陣列

六、指向函數指標陣列的指標

看起來很複雜，其實仔細分析也不難。

這裡的函數指標陣列指標不就是一個指標嘛。只不過這個指標指向一個陣列，這個陣列裡面存的都是指向函數的指標。僅此而已。（套娃）

那如何定義呢？下面程式碼介紹

void test(const char* str) {
 printf("%sn", str);
}
int main()
{
 //函數指標pfun
 void (*pfun)(const char*) = test;
 //函數指標的陣列pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函數指標陣列pfunArr的指標ppfunArr
 void (*(*ppfunArr)[10])(const char*) = &pfunArr;
 return 0; }

七、回撥函數

根據維基百科的解釋：

把一段可執行的程式碼像引數傳遞那樣傳給其他程式碼，而這段程式碼會在某個時刻被呼叫執行，這就叫做回撥。如果程式碼立即被執行就稱為同步回撥，如果在之後晚點的某個時間再執行，則稱之為非同步回撥

比如：

函數 F1 呼叫函數 F2 的時候，函數 F1 通過引數給函數 F2 傳遞了另外一個函數 F3 的指標，在函數 F2 執行的過程中，函數F2 呼叫了函數 F3，這個動作就叫做回撥（Callback），而先被當做指標傳入、後面又被回撥的函數 F3 就是回撥函數。

舉個例子：

int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}
void Cale(int(*pf)(int, int))//通過指標傳地址
{
	int ret = pf(3, 5);
	printf("%dn", ret);
}

int main()
{
	//Cale(Add);
	Cale(Sub);//呼叫函數
	return 0;
}