指標其實也沒有那么難 — 初級指標
本章內容是指標的內容，有哪些地方寫的不好還請多多指點，??
首先說一下指標的初級知識點什么是指標，
指標是什么?
按傳統的方式來講：
在計算機科學中，指標（Pointer）是編程語言中的一個物件，利用地址，它的值直接指向
（points to）存在電腦存盤器中另一個地方的值，由于通過地址能找到所需的變數單元，可以
說，地址指向該變數單元，因此，將地址形象化的稱為“指標”，意思是通過它能找到以它為地址
的記憶體單元，
記憶體單元是什么呢？就好比現實生活中我們的房間，不就是哪個單元哪個房間號嘛，
我們用畫圖的形式來展示，
指標
指標是個變數，存放記憶體單元的地址（編號），
用代碼方式表示:
#include <stdio.h>
int main()
{
int i = 9;//向記憶體申請一塊空間
int* p = &i;//&i 取出i的地址 放到p變數中 而p就是一個指標變數 它指向的是i變數所在的地址
return 0;
}
簡單的來說: 指標就是個變數，這個變數是用來存放地址的，（存放到指標變數中的值都將被當作地址處理），
比如說: int* p = 12;
資料在記憶體中都是地址的形式存放的，而在記憶體中地址是以4位16進制和8位16進制表示的，而12的16進制不就是字母C嗎，
上面一行代碼解釋為：定義一個整型指標變數，把12這個值當作地址賦值給變數p，%p以地址的形式列印所以是 --> 0000000C，
- 一個小的單元到底是多大?（1個位元組）
對于32位機器來說，我們假設有32根地址線，每根地址線在尋找地址的時候產生一個電信號正電或者負電(1/0)
那么32根地址線產生的地址是:
00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
......
11111111 11111111 11111111 11111111
2的32次方個地址，
每個地址標識一個位元組，那么就可以給（2^32Byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB）
4GB的空閑編址，同樣的方法放到64位機器上，編址有16777216TB，是這么多嗎
，
這里我們就明白了：
- 在32位機器上，地址是32個0或者1組成的二進制序列，那地址就應該用4個位元組的空間來存盤，所以一個指標變數大小就是4個位元組
- 換做64位機器上，那地址就應該用8個位元組來存盤，指標變數大小就是8個位元組，
由此我們得出結論：
- 指標是用來存放地址的，地址是唯一標示一塊地址空間的，
- 指標的大小在32位平臺上是4個位元組，在64位平臺上是8個位元組，
指標和指標型別
在此之前我們學過基本型別有：整型、字符型、浮點型等，既然指標也是變數，那指標是不是也會有不同的型別呢?答案是肯定的!
指標也是變數，所以也會有該對應的指標型別，下面舉幾個例子：
#include <stdio.h>
int main()
{
int a = 10;//整型
char b = 'w';//字符型
float c = 3.14;//單精度浮點型
double d = 123.789;//雙精度浮點型
int* pa = &a;//整形指標
char* pb = &b;//字符指標
float* pc = &c;//浮點型指標
double* pd = &d;//浮點型指標
return 0;
}
以上代碼就列舉了部分指標型別，
下面我們來看一段代碼
sizeof()是計算資料大小的運算子，單位是位元組，可以看到不管是什么型別的指標都是4個位元組，誒~既然大小都是4個位元組，那我們定義不同型別的指標又有什么意義呢?那我們何不造一個通用型別的指標呢?當然不行呢，你看我們每個人每天都要吃飯，雖然說有不同的方式可以讓自己吃飽，但是為什么要這么多不同的食品讓我們填飽肚子呢？直接造一種可以讓人吃飽的食品不就好了，這個時候大家又知道了不同的食品有不同的作用，有些要補維生素A呀或者是維生素B呀等等，同樣的指標型別也會有它不同的意義呀！
下面我們繼續看段代碼
我們看到記憶體上，a的地址，后面是變數a的資料存盤方式 -->小端存盤方式，當我們把a的地址存放到變數pa中，我們通過地址去改變a的值，請看下面
右下角我們看到pa變數的值變成了a的地址，而且a的值也被改成了20，好這個看不出什么，下面我們看另外一段代碼
跟上面一樣，我只是改變了指標的型別，改變指標型別后我們看到*pa=20執行之后，為什么右上角的值變成了 14 46 13 00呢?
通過觀察，指標型別不同，操作的位元組數就不同，可以看到int* 指標改變的是4個位元組，而char* 指標改變的是1個位元組，
由此我們得出結論:
指標型別決定了，對指標解參考的時候有多大權限（能操作幾個字符），比如說：char* 的指標解參考就只能訪問一個位元組，而int*的指標解參考能訪問4個位元組，
指標型別意義1：
指標型別決定了指標解參考時，能訪問的空間大小，
我們繼續看下面一段代碼的運行結果:
可以看到int型別指標p的地址與p+1的地址之間差了4 而char型別指標pc和pc+1的地址之間差了1，雖然說是以陣列來舉例子，不過就算不用陣列舉例也是一樣的，
指標型別意義2：
指標型別決定了指標+1或者-1有多大距離（指標的步長），也就是位元組
這有啥用呢？
可以知道我們創建了一個整型陣列，這個陣列有10個元素全部初始化成0了，陣列名代表陣列首元素的地址，把陣列首元素的地址傳給變數p通過回圈給陣列賦值，
結果很明顯，通過指標+整數訪問陣列的元素，然后再給陣列元素賦值，那么我們把指標型別改一下呢會出現什么效果？
它改變的是什么？搜嘎斯內，它只改變了整型資料中一個位元組的內容，這是一個位元組一個位元組的訪問，沒改變指標型別之前呢，沒改變之前是4個位元組4個位元組的訪問所以啊，
- 希望一個位元組一個位元組訪問 可以用char型別的指標
- 一個整型一個整型訪問 可以用int型別的指標
以此類推，想怎樣訪問就用什么樣型別的指標，
總結一下指標型別的作用：
- 指標型別決定了指標解參考（訪問位元組）的權限有多大，
- 指標型別決定了指標向前走或者向后走有多大（距離，步長），
野指標
野指標，大家看到會想起啥？野狗？野貓？它們都是沒得家的沒得主人，到處流浪，那么野指標是啥？
先按傳統的說法：
野指標就是指標指向的位置是不可知的（隨機的、不正確的、沒有明確限制的）
那為什么會產生野指標這玩意兒呢？
接下來我們看看野指標形成的原因，
野指標成因
1.指標未初始化
#include <stdio.h>
int main()
{
int* p ;//定義一個區域的指標變數，區域變數不初始化的話，默認是隨機值
*p = 10;//*p是對指標的解參考操作，這里非法訪問記憶體
//使用了未初始化的區域變數p
//使用未初始化的記憶體p
return 0;
}
2.指標越界訪問
int main()
{
int arr[10] = { 0 };
int* p = arr;
int i = 0;
for (i = 0; i <= 10; i++)
{
//當指標指向的范圍超出陣列arr的范圍時，p就是野指標
*p = i;
p++;
}
return 0;
}
3.指標指向的空間釋放
int* work()
{
int a = 20;//函式呼叫后變數a銷毀了
return &a;//所以此時a的地址雖然說還是那地址，但是指向的那塊空間已經還給了作業系統
}
int main()
{
int* p = work();
//對p指標的解參考 去訪問一個已經還給作業系統的空間 那片空間說不定作業系統已經存放其他內容 而且這也是屬于非法訪問記憶體
*p = 30;
return 0;
}
說了這么多的野指標成因，那我們應該怎樣有效的避免野指標的產生呢？
- 初始化指標
- 小心指標越界
- 指標指向空間釋放即使置NULL
- 指標使用之前檢查有效性 可用assert斷言
#include <stdio.h>
int main()
{
//當不知道p應該初始化為什么地址的時候，可以初始化NULL
int* p = NULL;//初始化指標
return 0;
}
指標運算
指標運算有3種形式：
- 指標±整數
- 指標-指標
- 指標的關系運算
指標±整數
int main()
{
int arr[10] = { 20,21,22,23,24,25,26,27,28,29 };
int* p = arr;
int* end = arr + 9;
while (p <= end)
{
printf("%d\n", *p);
p++;//指標+整數 p+=1;
}
return 0;
}
可以知曉，指標＋整數 在整型陣列中訪問下一個元素，既然可以＋那肯定也能－
指標－整數
指標－指標
指標－指標，聯系之前學過的內容，指標不就是地址嘛，那指標-指標 不就是 地址 - 地址，指標+指標沒啥意義，就和日期一樣，日期+日期有啥用嘛？日期-日期可以，日期+天數也可以，但是日期加日期就沒啥意義了，
#include <stdio.h>
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int* p = arr;
int* end = arr + 9;
printf("%d\n", end - p);
return 0;
}
代碼運行如下:
運行結果是9，我們發現從arr[0]到arr[9]之間剛好就是9個元素，
試試arr - （arr +9）這不是-9嘛看看代碼運行效果:
結果也是-9，雖然數字是相同了，但是符號卻不相同，而陣列中是隨著陣列下標的增長地址是由低到高的，記憶體中地址也是由低到高，
因此我們如要需要得到元素的個數，應該用高地址－ 低地址，
注意事項：
指標-指標的前提是：兩個指標指向的是通一塊空間
給大家來個實際點的：
#include <stdio.h>
//函式遞回方法
int me_strlen(char*str)
{
if(*str != '\0')
return 1 + me_strlen(str + 1);
else
return 0;
}
int me_strlen(char* str)
{
char* p = str;//p指標指向 str 變數 str 指向的是 字串首字符的地址
while(p != '\0')//字串長度是找'\0'
{
p++;
}
return p - str;//指標-指標 就是中間元素個數
}
int main()
{
char arr[] = "hello world";
int ret = me_strlen(arr);//傳字串首字符的地址
return 0;
}
指標關系的運算
指標關系運算，我們知道關系運算是啥，關系運算不就是 > < >= <= != ==
用代碼舉個例子吧:
#include <stdio.h>
int main()
{
int arr[5];
int *p;
for( p = &arr[5]; p > arr[0])
{
*--p = 0;
}
return 0;
}
這個代碼不太標準，看著有點難受，修改一下
#include <stdio.h>
int main()
{
int arr[5];
int *p;
for( p = &arr[4]; p > arr[0]; p--)
{
*p = 0;
}
return 0;
}
這個代碼是什么意思呢？咱們畫圖理解一下
該代碼的意思是：取出arr陣列后面一個元素的地址，判斷該地址是否大于陣列首元素的地址，如果大于那就把p變數所指向的內容改為0，然后在自減，也就是往arr[0]那邊走，再以同樣的方式賦值，直到p的地址要小于或者是等于arr[0]回圈就結束，
但是請注意：
允許指向陣列元素的指標與指向陣列最后一個元素后面的那個記憶體位置的指標比較，但是不允許與指向第一個元素之前的那個記憶體位置的指標進行比較，
如果還不明白請自己畫圖理解一下，
指標和陣列
指標和陣列的關系：指標是地址嘛，而陣列名是陣列首元素地址， 我們舉個例子
有圖有真相(doge),可以看到arr和&arr[0]的地址是一樣的，所以說，陣列名就是陣列首元素地址，
#include <stdio.h>
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
int* p = arr;//p存放的就是陣列首元素地址
return 0;
}
但是陣列名就一定是陣列首元素地址嗎？NONONO，也有例外啦！請記住下面2點
- sizeof(陣列名) --> 只有陣列名沒有其他運算子 陣列名表示整個陣列，計算的是整個陣列的大小，單位是位元組，
- &陣列名 -- > 取出的是整個陣列的地址 陣列名表示整個陣列
其他情況下，陣列名就是首元素地址，
首元素的地址和陣列的地址有啥區別呢？
靠，這不一樣嘛(手動狗頭)?雀食哈，這列印出來都一樣，但是意義卻截然不同呢，不信再舉個例子：
看到區別沒，arr是陣列名，代表首元素地址，+1 因為陣列型別是int 而int型別指標+1 不就是跳過4個位元組 剛好差4，
而&arr，arr代表整個陣列，+1 跳過了一個陣列，兩個地址之間差 40個位元組，
既然可以把陣列名當成地址存放到一個指標中，我們可以使用指標來一個個的訪問，
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%p <==> %p\n", &arr[i], p + i);
*(p + i) = i;
}
return 0;
}
效果：
所以 p+i 其實計算的是陣列 arr 下標為i的地址 ，
那我們就可以直接通過指標來訪問陣列 ，
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//陣列名
int sz = sizeof(arr)/sizeof(arr[0]);
int i = 0;
for(i=0;i<sz;i++)
{
printf("%d",*(p+1));
}
//[ ]是運算子 2和arr是兩個運算元
printf("%d \n", 2[arr]);
printf("%d \n", arr[2]);
printf("%d \n", 2[p]);//p[2] --> *(p+2)
//arr[2] --> *(arr+2) --> *(2+arr) --> 2[arr]
//arr[2]<==> *(arr+2) <==> *(p+2) <==> *(2+p) <==> *(2+arr) == 2[arr]
//2[arr] <==> *(2+arr)
return 0;
}
二級指標
二級指標，有沒有覺得好高級，之前了解到指標本質上還是變數嘛，只是用來存放地址的變數而已，既然是變數那它是不是也會有地址？
那當然，那么存放指標變數的地址就叫二級指標咯，畫圖舉個例子就知道了：
這樣是不是好理解一些，
#include <stdio.h>
int main()
{
int a= 1;
int* p = &a;//p是指標變數，一級指標
int** pa = &p;//pa也是指標變數，二級指標
return 0;
}
說完了什么是二級指標，那二級指標如何使用呢？其實和一級指標的使用是類似的，
-
*pa 通過對pa的地址解參考，找到p， *pa其實訪問的就是p，
int b = 1; *pa = &a;//等價于 p = &a; -
**pa先通過 *pa找到p，然后對p進行解參考操作： *p，找到a
**pa = 30; //等價于*pa = 30; //等價于a = 30;
指標陣列
我們學過整型陣列、字符型陣列，那么指標有沒有陣列呢?
答案肯定是有的，還記得陣列的定義是什么嗎？陣列是一組相同型別元素的集合，那么一組相同型別的指標放在一起這算不算是陣列呢？
這肯定是陣列，因為它滿足陣列的定義，那么指標陣列又是怎么樣的呢？
首先指標陣列的定義：一組相同型別的指標的集合，
int arr[10];//這是整型陣列，陣列有10個元素，陣列中每個元素都是整型，
char arry[5];//這是字符型陣列，陣列有5個元素，陣列中每個元素都是字符型，
#include <stdio.h>
int main()
{
int a = 1;
int b = 2;
int c = 3;
int* pa = &a;
int* pb = &b;
int* pc = &c;
return 0;
}
這段代碼中，a、b、c均為整型變數，pa、pb、pc均為整形指標，3個整型變數用3個整型指標來接收豈不是浪費空間了？那我們干脆把這3個整型指標放在一起組成一個整型指標陣列不就好了嘛，誒指標陣列這不就出來了嘛，
首先定義一個陣列 int arr[10]; 既然每個型別都是指標，那么把陣列的型別改一下不就好了嘛， int* arr[10]; 這時我們就說這個陣列是指標陣列嘛，這是一個整型指標陣列，該陣列有10個元素且每一個元素都是整型指標，那么我們畫圖展示一下：
用代碼的形式:
int main()
{
int arr[10];//整形陣列 - 存放整形的陣列就是整形陣列
char ch[5];//字符陣列 - 存放的是字符
//指標陣列 - 存放指標的陣列
int* parr[5];//整形指標的陣列
char* pch[5];//字符型指標陣列
return 0;
}
想必大家看了這幾幅圖和代碼，對指標陣列應該有大概的了解了吧，
感謝大家的收看，以上都是鄙人學習的個人理解如果有哪些地方說錯了或者是沒有講明白，還請大家多多指點指點，謝謝大家！！！
這部分是鄙人對指標的初步了解后面進階的會在【指標其實也沒有那么難—進階指標】這篇中講解，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/379038.html
標籤：C