C語言指針怎么用

這篇文章主要為大家展示了“C語言指針怎么用”，內(nèi)容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領(lǐng)大家一起研究并學習一下“C語言指針怎么用”這篇文章吧。

一、字符指針

在指針的類型中我們知道有一種指針類型為字符指針 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里了，但是/本質(zhì)是把字符串 hello boy首字符的地址放到了p中。

思考下面代碼，輸出的是什么？

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

	if (str1 == str2)//比較兩個數(shù)組的地址，肯定不相等
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");

	return 0;
}

所以結(jié)果如下圖

二、指針數(shù)組和數(shù)組指針

指針數(shù)組是指針還是數(shù)組？

答案是：數(shù)組。

數(shù)組指針是指針還是數(shù)組？

答案是：指針。

舉個例子：

int *p1[5];  //指針數(shù)組
int (*p2)[5];  //數(shù)組指針

二者形式很相似，那么我們?nèi)绾螀^(qū)分呢？

1.指針數(shù)組

【指針數(shù)組】

首先它是一個數(shù)組，數(shù)組的元素都是指針，數(shù)組占多少個字節(jié)由數(shù)組本身 決定。它是“儲存指針的數(shù)組”的簡稱。

指針數(shù)組是數(shù)組元素為指針的數(shù)組(例如 int *p[5],定義了p[0],p[1],p[2],p[3],p[4]五個指針)，其本質(zhì)為數(shù)組。

int *p[5];

這里涉及到一個優(yōu)先級的問題。

我們知道數(shù)組下標的優(yōu)先級比取值運算符的優(yōu)先級高。所以，p先被定義為具有5個元素的數(shù)組。它的類型是int*，所以它是指向整型變量的指針。

【結(jié)論】指針數(shù)組是一個數(shù)組，每個數(shù)組元素存放一個指針變量。

指針數(shù)組如何初始化呢？

int main()
{
	//char *arr[5];//arr是存放字符指針的數(shù)組
	//int * arr2[4];//arr2是存放整型指針的數(shù)組

	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	                //int* int* int* int*
	int * arr2[4] = { &a, &b, &c, &d };//arr2就是整型指針的數(shù)組
	printf("%d\n", *arr2[0]);//取出第一個地址的內(nèi)容
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d\n", *(arr2[i]));
	}
	return 0;
}

數(shù)組指針中&a，&b,&c,&d分別指向10，20，30，40

大家有沒發(fā)現(xiàn)，如果這樣定義的話，會有些繁瑣。

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

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

2.數(shù)組指針

2.1.數(shù)組指針是什么？

【數(shù)組指針】

首先它是一個指針，它指向一個數(shù)組。在 32 位系統(tǒng)下永遠是占 4 個字節(jié)，
至于它指向的數(shù)組占多少字節(jié)，不知道。它是“指向數(shù)組的指針”的簡稱。

數(shù)組指針是指向數(shù)組地址的指針，其本質(zhì)為指針。

int (*p)[5];

在上面代碼中，圓括號和數(shù)組下標位于同一優(yōu)先級隊列，所以從左到右執(zhí)行。

因此，p先被定義為一個指針變量，后邊[5]表示的是一個具有5個元素的數(shù)組，p指向的就是這個數(shù)組。

由于指針變量的類型事實上就是它所指向的元素的類型，所以這個int定義數(shù)組元素的類型為整型。

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

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


	int arr[10] = { 0 };
	int*p = arr;//arr-是數(shù)組首元素的地址

	//int* parr[10]; //這樣寫是數(shù)組
	int (*parr)[10]=&arr;//取出的是數(shù)組的地址,應(yīng)該存放到數(shù)組指針中
	return 0;
}

那么我們?nèi)绾芜M行初始化呢？

我們在學習指針的時候，是將指針指向數(shù)組名，因為數(shù)組名是數(shù)組首元素地址，知道了第一個元素的地址，后面的元素就可知道。如下：

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

所以，上面的指針p是一個指向整型變量的指針，它并不是指向數(shù)組的指針。而數(shù)組指針，才是指向數(shù)組的指針。

所以，在初始化的時候，應(yīng)該將數(shù)組的地址傳遞給數(shù)組指針，而不是傳遞數(shù)組第一個元素的地址。它們值雖然相同，但含義不一樣。

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

2.2.&數(shù)組名和數(shù)組名的區(qū)別

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

a,&a 的值是一樣的。
但意思不一樣，
a 是數(shù)組首元素的首地址，也就是 a[0]的首地址。
&a 是數(shù)組的首地址，表示的是數(shù)組的地址。

例如：

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

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

但是，如果它們+1呢？

如下：

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

可以看到，+1后的結(jié)果就不一樣了。

那么為什么呢？

a 是數(shù)組首元素的首地址，也就是 a[0]的 首地址。
&a 是數(shù)組的首地址。
a+1 是數(shù)組下一元素的首地址，即 a[1]的首地址。
&a+1 是下一 個數(shù)組的首地址。

2.3.數(shù)組指針的使用

數(shù)組指針指向的是數(shù)組，存放的是數(shù)組的地址

那怎么使用，舉個例子：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int (*p)[10] = &arr;//把數(shù)組arr的地址賦值給數(shù)組指針變量p
    //這里*先與p結(jié)合，再與 [ ] 結(jié)合，由于上面定義的數(shù)組是int類型，所以取地址的類型也是int類型。
    return 0; 
}

來看下面代碼，思考我們?nèi)绾卫脭?shù)組指針打印我們想要的結(jié)果呢？

void print(int (*parr)[10], int sz)//傳上來地址，用數(shù)組指針接受
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
	//以下3種方式都能打印
		//printf("%d ", parr[0][i]);//把一維數(shù)組當成二維數(shù)組，[0]表示第一行，[i]表示遍歷元素
		//printf("%d ", (*(parr + 0))[i]);//*(parr + 0)解引用首元素地址
		printf("%d ", (*parr)[i]);//(*parr) 相當于 parr指向的數(shù)組的數(shù)組名
	}
}
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把數(shù)組的首元素地址傳上去函數(shù)

	return 0;
}

三、數(shù)組參數(shù)與指針參數(shù)

我們都知道參數(shù)分為形參和實參。

形參是指聲明或定義函數(shù)時的參數(shù)
實參是在調(diào)用函數(shù)時主調(diào)函數(shù)傳遞過來的實際值。

1.一維數(shù)組參數(shù)

一維數(shù)組傳參是怎樣的呢?

我們先來看一個例子：

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

#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.二維數(shù)組參數(shù)

二維數(shù)組的傳參跟一維數(shù)組類似。

舉個例子：

同樣思考能否傳參成功？

void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//總結(jié)：二維數(shù)組傳參，函數(shù)形參的設(shè)計只能省略第一個[]的數(shù)字。
//因為對一個二維數(shù)組，可以不知道有多少行，但是必須知道一行多少元素。
//這樣才方便運算。
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("%d\n", *(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，傳給函數(shù)
	 print(p, sz);
	 return 0;
 }

那如果我們用一級指針接收傳過來的參數(shù)，我們的參數(shù)可以是什么樣的形式呢？

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

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

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

	test(&a);//傳地址上去可以
	test(arr);//傳個數(shù)組名過去可以
	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;
}

四、函數(shù)指針

函數(shù)指針是是什么？

我們說，數(shù)組指針就是數(shù)組的指針。是指向數(shù)組的指針。

同理

函數(shù)指針就是函數(shù)的指針。它是一個指針，指向一個函數(shù)

我們思考一下下面三個代碼：

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是函數(shù)名，p1，p2 是參數(shù)，其類型為 char *型，函數(shù)的返回值為 char *類型。

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

那么第一個代碼是什么意思？

這里 fun1 不是什么函數(shù)名，而是一個

指針變量，它指向一個函數(shù)。這個函數(shù)有兩個指針類型的參數(shù)，函數(shù)的返回值也是一個指針。

那么我們?nèi)绾问褂煤瘮?shù)指針呢？

#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;
}

我們使用指針的時候，需要通過鑰匙（“*”）來取其指向的內(nèi)存里面的值，函數(shù)指針使用也如此。通過用(*pf)取出存在這個地址上的函數(shù)，然后調(diào)用它。

給函數(shù)指針賦值時，可以用&fun 或直接用函數(shù)名 fun。這是因為函數(shù)名被編譯之后其實就是一個地址，所以這里兩種用法沒有本質(zhì)的差別。

接下來看一下下面這個代碼什么意思？

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

第一步：void(*) ()，可以明白這是一個函數(shù)指針類型。這個函數(shù)沒有參數(shù)，沒有返回值。

第二步：(void(*) ())0，這是將 0 強制轉(zhuǎn)換為函數(shù)指針類型，0 是一個地址，也就是說一個函數(shù)存在首地址為 0 的一段區(qū)域內(nèi)。

第三步：((void() ())0)，這是取 0 地址開始的一段內(nèi)存里面的內(nèi)容，其內(nèi)容就是保存在首地址為 0 的一段區(qū)域內(nèi)的函數(shù)。

第四步：((void() ())0)()，這是函數(shù)調(diào)用。

五、函數(shù)指針數(shù)組

把函數(shù)的地址存到一個數(shù)組中，那這個數(shù)組就叫函數(shù)指針數(shù)組

char * (*pf[3])(char * p);//一個函數(shù)指針數(shù)組，pf為數(shù)組名，類型是char*(*)()
//pf先于[3]結(jié)合，說明是一個數(shù)組，數(shù)組內(nèi)存儲了3個指向函數(shù)的指針
//指針再與*結(jié)合，說明是一個函數(shù)指針數(shù)組

六、指向函數(shù)指針數(shù)組的指針

看起來很復(fù)雜，其實仔細分析也不難。

這里的函數(shù)指針數(shù)組指針不就是一個指針嘛。只不過這個指針指向一個數(shù)組，這個數(shù)組里面存的都是指向函數(shù)的指針。僅此而已。（套娃）

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

void test(const char* str) {
 printf("%s\n", str);
}
int main()
{
 //函數(shù)指針pfun
 void (*pfun)(const char*) = test;
 //函數(shù)指針的數(shù)組pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函數(shù)指針數(shù)組pfunArr的指針ppfunArr
 void (*(*ppfunArr)[10])(const char*) = &pfunArr;
 return 0; }

七、回調(diào)函數(shù)

根據(jù)維基百科的解釋：

把一段可執(zhí)行的代碼像參數(shù)傳遞那樣傳給其他代碼，而這段代碼會在某個時刻被調(diào)用執(zhí)行，這就叫做回調(diào)。如果代碼立即被執(zhí)行就稱為同步回調(diào)，如果在之后晚點的某個時間再執(zhí)行，則稱之為異步回調(diào)

比如：

函數(shù) F1 調(diào)用函數(shù) F2 的時候，函數(shù) F1 通過參數(shù)給函數(shù) F2 傳遞了另外一個函數(shù) F3 的指針，在函數(shù) F2 執(zhí)行的過程中，函數(shù)F2 調(diào)用了函數(shù) F3，這個動作就叫做回調(diào)（Callback），而先被當做指針傳入、后面又被回調(diào)的函數(shù) F3 就是回調(diào)函數(shù)。

舉個例子：

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("%d\n", ret);
}

int main()
{
	//Cale(Add);
	Cale(Sub);//調(diào)用函數(shù)
	return 0;
}

以上是“C語言指針怎么用”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內(nèi)容對大家有所幫助，如果還想學習更多知識，歡迎關(guān)注億速云行業(yè)資訊頻道！