文章目錄

前言
為什么要學習指標
什么是指標
指標詳解
- 一、基礎知識
- - 1、取地址
  - 2、解參考
  - 3、指標變數
- 二、指標與指標型別
- - 1、指標型別
  - 2、野指標
  - 3、指標運算
  - 4、二級指標
- 三、指標的分類
- - 1、字符指標
  - 2、指標和陣列
  - - （1）陣列名
    - （2）指標陣列
    - （3）陣列指標
  - 3、指標和函式
  - - （1）指標傳參
    - （2）函式指標
    - （3）指標函式
  - 4、指標和結構體
  - - （1）結構體內包含指標
    - （2）結構體指標
結束語

前言

指標，是C語言中的一個重要概念及其特點，也是掌握C語言比較困難的部分，作為一個C語言初學者，我對指標也有了一定的了解，正好這幾天在做一個C語言指標的知識點匯總，于是就有了這篇文章，向大家分享一些我的見解，與大家一起共勉，

為什么要學習指標

如果你想通過函式改變一個變數的值，就得用指標而不能用值傳遞，很多時候不同的函式存在很多不同的變數，當程式的資料量十分龐大的時候，我們就需要用指標來作為形參，通過傳遞地址，達到傳遞變數的目的，
指標變數是用來存放記憶體地址的變數，在同一CPU構架下，不同型別的指標變數所占用的存盤單元長度是相同的，而存放資料的變數因資料的型別不同，所占用的存盤空間長度也不同，有了指標以后，不僅可以對資料本身，也可以對存盤資料的變數地址進行操作，
同樣，指標也使得一些復雜的內容變得簡單，例如：鏈表等等；也有一些操作它必須使用指標，例如：申請記憶體等等，

什么是指標

在計算機中，每一個資料都是存放在儲存器中的，而不同的資料型別所占的記憶體空間不同（例如：int型別占用4個位元組，double型別占用8個位元組等等），記憶體空間又是以位元組為單位的，每一個位元組又對應了一個編號，這個編號我們稱為這一個記憶體單元的地址，

而系統在記憶體中又為變數分配了存盤空間的首個位元組單元的地址即變數的地址，為了方便用戶對存盤空間進行正確的訪問，指標便應運而生了，

指標相對于一個記憶體單元來說，指的是單元的地址，該單元的內容里面存放的是資料，在 C 語言中，允許用指標變數來存放指標，因此，一個指標變數的值就是某個記憶體單元的地址或稱為某記憶體單元的指標，

指標變數是存放一個記憶體地址的變數，不同于其他型別變數，它是專門用來存放記憶體地址的，也稱為地址變數，定義指標變數的一般形式為：型別說明符*變數名，

指標詳解

一、基礎知識

在C語言中，定義變數時，如果在變數名前加上一個 “ * ”，那么這個變數就變成了對應變數型別的指標變數，

1、取地址

對于一個指標變數，我們需要讓它來保存其他變數的地址的時候，就需要用到 &運算子，
下面舉個例子：

例1

#include<stdio.h>
int main()
{
	int num = 10;//在記憶體中開辟一塊空間
	int* p = &num;//這里我們對變數num取地址，使用了&運算子
				  //將num的地址存放在p變數中，p就是一個指標變數，
	return 0;
}

&num就取得了num的地址，指標p指向的num的地址，就形成了一個簡單的指標變數，

但是對于某些特殊情況，我們可以不需要用&運算子，例如：陣列，函式等等，我們后邊會講到，

2、解參考

上面我們了解了如何取得一個資料的地址，那么接下來我們可以嘗試運用指標來解地址，從而得到這個變數的記憶體資料，

在指標前加一個“ * "即解參考地址，也就是從指標指向的記憶體中，取出這段記憶體地址對應的資料，

輸出例1中的指標p：

例2

#include<stdio.h>
int main()
{
	int num = 10;
	int* p = &num;
	printf("%d", *p);
	return 0;
}

運行結果為：10

3、指標變數

指標就是一個變數，用來存放地址的變數，（存放在指標中的值，均會被看作地址）

一個小的單元會有多大：（一個位元組）
那么地址是如何撰寫的呢？

目前經過仔細的技術及思考后，最合適的結論為：一個位元組對應了一個地址，

對于32位機器，可以看作有32根地址線，每一根地址線在尋址的時候都會產生一個電信號（正電1/負電0），所以它的地址從000……000（32個0）到111……111（32個1）共有2的32次方個地址，

在32位機器上，地址是32個0或1組成的二進制序列，一個地址需要用4個位元組的空間來存盤，所以一個指標變數的大小就是4個位元組，

同樣，可以類比推理得到：64位機器有2的64次方個地址，一個指標變數的大小位8個位元組，

我們來做一個練習：

例3

#include<stdio.h>
int main()
{
	printf("%d\n", sizeof(char*));
	printf("%d\n", sizeof(short*));
	printf("%d\n", sizeof(double*));
	printf("%d\n", sizeof(int*));
	return 0;
}

運行結果為：
4
4
4
4

總結
（1）指標是一個變數，它存放的是地址，
（2）指標在32位機器中占4個位元組，在64位機器中占8個位元組，與型別無關，

二、指標與指標型別

1、指標型別

我們前邊提到，指標的定義方式是：type + * ：
char* 型別的指標是為了存放char型別變數的地址；
int* 型別的指標是為了存放int型別變數的地址；
short* 型別的指標是為了存放short型別變數的地址；
double* 型別的指標是為了存放double型別變數的地址，

指標的型別決定了指標向前或者向后的空間有多大，

指標型別決定了指標進行解參考操作的時候，能夠訪問空間的大小：
（1） int* p：* p能夠訪問4個位元組，
（2）char* p：* p能夠訪問1個位元組，
（3）double* p： *p能夠訪問8個位元組，

指標型別的意義

先來看一個例子：

例4

#include<stdio.h>
int main()
{
	int a = 10;
	char* p1 = (char*)&a;
	int* p2 = &a;

	printf("%p\n", &a);
	printf("%p\n", p1);
	printf("%p\n", p1+1);
	printf("%p\n", p2);
	printf("%p\n", p2+1);
	return 0;
}

輸出的結果為：
003CFC80
003CFC80
003CFC81
003CFC80
003CFC84

我們可以看到不同型別的指標p1和p2都指向了變數a的地址，但是p1+1指向的是003CFC81，而p2+1指向了003CFC84，一個地址向后移動了1，一個地址向后移動了4，

這是因為：指標的型別決定了指標向前或者向后移動一步有多大的距離，

2、野指標

（1）概念：
野指標就是指標指向的位置是不可知的（隨機的、不正確的、沒有明確限制的），

（2）成因：
①指標未初始化
例5

#include<stdio.h>
int main()
{
	int* p;//區域變數指標未初始化，默認未隨機值，
	*p = 10;
	return 0;
}

②指標越界訪問
例6

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 11; i++)
	{
		//當指標指向的范圍超出陣列arr的范圍時，p就是野指標
		*(p++) = i;
	}
	return 0;
}

③指標指向的空間釋放
例7

#include<stdio.h>
int* func()
{
	int a = 10;
	printf("%p\n", &a);
	return &a;
}
int main()
{
	int* p = func();
	//回傳的地址是跟a的地址一致 
	printf("%p\n", p);
	//但指標對應的值卻不是變數a原來的值了 
	printf("%d\n", *p);
	return 0;
}

運行結果為：
0093F7F4
0093F7F4
10361167

這里的func函式雖然確實回傳了地址，而p也確實接受到了回傳的地址，但是當回傳的時候，已經來不及保存了，因為func函式一結束，函式申請的記憶體等等就回傳給作業系統了，已經無法再通過指標p去訪問a的地址了，后邊再用*p=20去訪問的是已經被釋放的a的地址，

（3）如何避免野指標
①指標初始化
例8

#include<stdio.h>
int main()
{
	int a = 10;
	int* p1 = &a;
	int* p2 = NULL;//NULL:用來初始化指標的，給指標賦值，
	return 0;
}

②小心指標越界
③指標指向空間釋放即設定NULL
④指標使用之前檢查有效性
例9

#include<stdio.h>
int main()
{
	int* p = NULL;
	int a = 10;
	p = &a;
	if (p != NULL)
	{
		*p = 20;
	}
	return 0;
}

3、指標運算

（1）指標±整數

例10：輸出陣列的每一個元素

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
	return 0;
}

運行結果為：1 2 3 4 5 6 7 8 9 10

（2）指標-指標
指標-指標得到的是中間的元素個數，（注意盡量大-小）

易錯點提示：兩個指標不能進行加法運算，這是非法的！！！兩個指標在進行減法運算時，型別要相同，否則結果不可預知！！！

例11

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p1 = &arr[0];
	int* p2 = &arr[9];
	printf("%d\n", *p2 - *p1);
	return 0;
}

運行結果為：9

我們在之前學過了用遞回和迭代兩種方法來實作strlen函式，那么今天我們就學會了第三種方法——指標相減法：

例12：自己的strlen函式（指標相減法）

#include<stdio.h>
int my_strlen(char* str)
{
	char* ret = str;
	while (*str != '\0')
	{
		str++;
	}
	return str - ret;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d", len);
	return 0;
}

（3）指標的關系運算——"<" “>” “<=” “>=” “==” “!=”
指標進行關系運算的前提是它們都指向同一個陣列中的元素，

易錯點提示：指標的關系運算是相同型別的指標之間的關系運算，不同型別的指標之間的關系運算沒有意義，指標與非0整數的關系運算也沒有意義，
例13

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	int* q = &arr[9];
	p < q; //當p所指的元素在q所指的元素之前時，運算式的值為1；反之為0，
	p > q; //當p所指的元素在q所指的元素之后時，運算式的值為1；反之為0，
	p == q; //當p和q指向同一元素時，運算式的值為1；反之為0，
	p != q; //當p和q不指向同一元素時，運算式的值為1；反之為0，
	printf("%d %d %d %d", p < q, p > q, p == q, p != q);
	return 0;
}

運行結果為：1 0 0 1

4、二級指標

例14

#include<stdio.h>
int main()
{
	int a = 10;
	int* p1 = &a;
	int** p2 = &p1;//p2就是二級指標，
	printf("%d\n", **p2);
	
	**p2 = 20;//二級指標p2改變，其指向的a隨之改變，
	printf("%d\n", **p2);
	printf("%d\n", a);
	return 0;
}

運行結果為：
10
20
20

三、指標的分類

1、字符指標

指向字符型資料的指標變數，每個字串在記憶體中都占用一段連續的存盤空間，并有唯一確定的首地址，即將字串的首地址賦值給字符指標，可讓字符指標指向一個字串，

下面舉一個例子：
例15

#include<stdio.h>
int main()
{
    char arr[] = "abcdef";
    char* p1 = arr;
    printf("%s\n", arr);
    printf("%s\n", p1);
    //這里的字符指標p1指向的是arr[]中首位的地址，所以在列印時不用解參考，它表示的是從arr[]的首位開始列印至"\0"停止，

    char* p2 = "abcdef";//"abcdef"是一個常量字串，
    printf("%c\n", *p);//說明p存的只是首元素a的地址，
    printf("%s\n", p);//同上
    return 0;
}

運行結果為：
abcdef
abcdef
a
abcdef

易錯點提示：在常量字串前加一個“const”，

例16：常量字串

#include<stdio.h>
int main()
{
    const char* p = "abcdef";
    //*p = 'w';
    printf("%s\n", p);
    return 0;
}

運行結果為：abcdef

有了const以后，我們就不能對指標p進行賦值修改了，這樣可以使其更加安全的儲存資料，

例17：經典易錯題

#include<stdio.h>
int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "abcdef";
    char* p1 = "abcdef";
    char* p2 = "abcdef";
    if (arr1 == arr2)
        printf("1\n");
    else
        printf("0\n");
    if (p1 == p2)
        printf("1\n");
    else
        printf("0\n");
    return 0;
}

運行結果為：
0
1
這是因為arr1和arr2是分別開辟的記憶體，雖然元素相同，但所處記憶體空間不同，所以arr1 ！= arr2；但是字符指標p1和p2都指向了字串"abcdef"，指向相同，所以p1 == p2，

2、指標和陣列

（1）陣列名

陣列名表示的是陣列首元素的地址，

例18

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);//arr:首元素的地址，
	printf("%p\n", arr + 1);

	printf("%p\n", &arr[0]);//&arr[i]:陣列中對應元素的地址，
	printf("%p\n", &arr[0] + 1);

	printf("%p\n", &arr);//&arr:整個陣列的地址，
	printf("%p\n", &arr + 1);

	//1. &arr — &陣列名:陣列名不是首元素地址，陣列名表示整個陣列，&陣列名-取出的是整個陣列的地址，
	//2.sizeof（arr） — sizeof（陣列名）：陣列名表示的整個陣列，sizeof（陣列名）計算的是整個陣列的大小，

	return 0;
}

運行結果為：
00B3F828
00B3F82C
00B3F828
00B3F82C
00B3F828
00B3F850

也就是說，對于上述代碼，arr與&arr[0]通過加1運算后發現地址加了4，而&arr通過加1運算后發現地址加了40，從而說明了&arr表示的是整個陣列的地址，

（2）指標陣列

概念：陣列元素全為指標變數的陣列稱為指標陣列，
也就是指標陣列是一個陣列，用來存放指標的陣列，
如：*p[10]是一個指標陣列，

舉一個例子：
例19

#include<stdio.h>
int main()
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[] = { 2,3,4,5,6 };
    int arr3[] = { 3,4,5,6,7 };

    int* arr[] = { arr1,arr2,arr3 };
    int i = 0;
    //分別遍歷出arr1，arr2，arr3，
    for (i = 0; i < 3; i++)
    {
        int j = 0;
        //分別遍歷出arr1,arr2,arr3中的每個元素，
        for (j = 0; j < 5; j++)
        {
            printf("%d ", *(arr[i] + j));
        }
        printf("\n");
    }
    return 0;
}

運行結果為：
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7

（3）陣列指標

概念：指的是陣列名的指標，即陣列首元素地址的指標，
也就是陣列指標是一個指標，指向陣列的指標，
如：(*p)[10]是一個陣列指標，

舉一個例子：
例20

#include<stdio.h>
void print1(int arr[3][5], int x, int y)//二維陣列列印，
{
    int i, j = 0;
    for (i = 0; i < x; i++)
    {
        for (j = 0; j < y; j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}
void print2(int (*p)[5], int x, int y)//陣列指標列印
{
    int i = 0;
    for (i = 0; i < x; i++)
    {
        int j = 0;
        for (j = 0; j < y; j++)
        {
            printf("%d ", *(*(p+i)+j));
        }
        printf("\n");
    }
}
int main()
{
    int arr[3][5] = { { 1,2,3,4,5 },{ 2,3,4,5,6 },{ 3,4,5,6,7 } };
    
    print1(arr, 3, 5);//引數是陣列的形式，
    print2(arr, 3, 5);//引數是指標的形式，
    return 0;
}

運行結果為：
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7

3、指標和函式

（1）指標傳參

對于普通的引數傳遞，我們傳入的值是什么，函式呼叫完畢后，這個值還是什么；我們無法在函式呼叫之后，使用修改后的值，

而當我們使用指標進行傳遞的時候，就可以達到這個目的，因為指標傳遞的是變數的地址，而不是值，

下面來舉一個例子：
例21：輸出陣列中的最大值和最小值，

#include<stdio.h>
void minmax(int a[],int len,int *min,int *max)
{
	int i;
	*min = *max = a[0];
	for( i=1; i<len;i++){
		if( a[i] < *min ){
			*min = a[i];
		}
		else if( a[i] > *max){
			*max = a[i];
		}
	}
}
int main(void)
{
	int a[] = {1,2,3,4,5,6,13,14,56,12,42,13,9,8,10,19,23};
	int min,max;
	minmax(a,sizeof(a)/sizeof(a[0]),&min,&max);
	printf("min=%d,max=%d\n",min,max);
	return 0;
}

運行結果為：min=1,max=56

易錯點提示：
①指標變數實質是一個地址，這個地址指向一個記憶體，
②函式在傳遞引數時傳遞的一定是形參，

（2）函式指標

概念：指向函式的指標變數，
也就是函式指標是一個指標，指向函式的指標，
如：int *f(int a)是一個函式指標，

關于函式名，看一個實體，
例22

#include<stdio.h>
int ADD(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}
int main()
{
	int a = 10;
	int b = 20;
	int arr[10] = { 0 };
	printf("%p\n", &ADD);
	printf("%p\n", ADD);
	return 0;
}

運行結果為：
000B13BB
000B13BB

說明：&函式名和函式名都表示函式的地址，

再舉一個簡單的函式指標的例子，
例23：加法

#include<stdio.h>
int ADD(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}
int main()
{
	int(*p)(int x, int y) = ADD;
	printf("%d\n", (*p)(2, 3));
	return 0;
}

運行結果為：5

函式指標和陣列指標原理相同，他有兩種作用：
①呼叫函式，②做函式的引數（回呼函式），

劃重點：
① void * 型別的指標可以接受任意型別的地址，
（有點垃圾桶的意思？狗頭）
② void * 型別的指標不能進行解參考操作，
③ void * 型別的指標不能就行±整數的操作，

下面來舉個例子：
例24：

#include <stdio.h>
int main() 
{
	int a = 10;
	int* pa = &a;
	//char* pc = &a;
	
	char ch = 'w';
	void* p= &a;
	p = &ch;

	//*p = 0;
	//p++;
	return 0;
}

解讀：
①對于char* pc = &a 這種寫法，可以過編譯（ pc中能放下a的地址），但是會有一個警告（ C4133：“初始化” ：從 “int *” 到 “char *” 的型別不兼容），
但是對于void *型別就不會有警告出現，因為void * 型別指標可以接收任意型別的指標，
②同樣因為 void * 型別的指標型別未知，所以在進行解參考和 ±整數時會報錯，

回呼函式：
回呼函式就是一個通過函式指標呼叫的函式，如果你把函式的指標（地址）作為引數傳遞給另一個函式，當這個指標被用來呼叫其所指向的函式時，我們就說這是回呼函式，回呼函式不是由該函式的實作方直接呼叫，而是在特定的事件或條件發生時由另外的一方呼叫的，用于對該事件或條件進行回應，

最典型的莫過于qsort（）函式了，這個函式對應的頭檔案為#include<stdlib.h>，包含了4個引數：

void qsort( void* base,
			size_t num,
			size_t width,
			int(* cmp)(const void* e1, const void* e2)
			);

有興趣的朋友，可以自行查閱一下源代碼，這里就不過多闡述了，

來看使用qsort排序的函式：
例25：qsort函式的運用

#include<stdio.h>
#include<stdlib.h>
int cmp_int(const void* e1, const void* e2)
{
	//比較兩個整形值的
	return *(int*)e1 - *(int*)e2;
}

void test1()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int cmp_float(const void* e1, const void* e2)
{
	//比較兩個浮點型值的
	return ((int)(*(float*)e1 - *(float*)e2));
}

void test2()
{
	float f[] = { 9.0,8.0,7.0,6.0,5.0,4.0,3.0,2.0,1.0 };
	int sz = sizeof(f) / sizeof(f[0]);
	qsort(f, sz, sizeof(f[0]), cmp_float);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%.1f ", f[i]);
	}
	printf("\n");
}

int main()
{
	test1();
	test2();
	return 0;
}

運行結果為：
0 1 2 3 4 5 6 7 8 9
1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0

（3）指標函式

概念：回傳某一型別指標的函式，
也就是指標函式是函式，回傳值為指標的函式，
如： int (*f)(int a)是一個指標函式，

下面舉一個例子：
例26

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//指標函式的簡單例程 malloc strcpy
char *fun()
{
    char *pa;
    pa = (char *)malloc(40); //申請記憶體
    //一定記得要寫出錯判斷
    if(NULL == pa)
    {
        printf("malloc error\n");
        exit(1);
    }
    strcpy(pa,"Welcome to xiyou!");//字串拷貝函式
    return pa;
}

int main(void)
{
    char *p;
    p = fun();
    printf("%s\n",p);

    return 0;
}

運行結果為：Welcome to xiyou!

4、指標和結構體

（1）結構體內包含指標

宣告一個結構體：
例27

#include <stdio.h>
#include <string.h>

typedef struct _person {//結構體的宣告
	char* name;
	int age;
}Person;
int main() {
	Person stu;//結構體實體宣告
	stu.name = "zhangsan";//點表示法訪問其欄位
	stu.age = 20;
	printf("%s %d\n",stu.name,stu.age);
	return 0;
}

運行結果為：
zhangsan 20

我們可以直接使用.來進行結構體資料的訪問，更加便捷！

（2）結構體指標

①我們可以使用指標來訪問變數，同時還能當做函式的引數進行傳遞
舉一個例子：
例28：按照年齡錄入資訊

#include<stdio.h>
#include<stdlib.h>
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

int main()
{
	struct Stu s[3] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%8s-%2d\n", s[i].name,s[i].age);
	}
	printf("\n");
	return 0；
}

運行結果為：
wangwu-10
zhangsan-20
lisi-30

為了使用的方便和直觀，用指標參考結構體變數成員的方式：
(*指標變數名).成員名
可以直接用：
指標變數名->成員名

②用來構造資料結構
鏈表，二叉樹這些資料結構都是由結構體組成的，這里就不展開講了，
例29

typedef struct Student
{
  int num;
  struct Student *next;
}Student;

void main()
{
  Student* p;
  Student Stu1;
  p = &Stu1;
  p->num = 1;
}

結束語

歷經了千難萬險，有關指標的介紹到此結束，本文章只是很簡單的介紹向大家介紹了指標的冰山一角，指標的奇妙遠不止于此，還需要我們在日常學習中慢慢積累，厚積才能薄發，各位，我們以此共勉！！！

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/356120.html

標籤：其他

上一篇：資料結構之二叉樹詳解

下一篇：帶頭雙向回圈鏈表

C語言指標講解