0x05-C語言指針:(Volume-1)

這似乎是一個很凝重的話題，但是它真的很有趣。

1. 指針是指向某一類型的東西，任何一個整體，只要能稱為整體就能擁有它自己的獨一無二的指針類型，所以指針的類型其實是近似無窮無盡的

2. 函數(shù)名在表達式中總是以函數(shù)指針的身份呈現(xiàn)，除了取地址運算符以及sizeof

3. C語言最晦澀難明的就是它復雜的聲明: void (*signal(int sig, void (*func)(int)))(int),試試著把它改寫成容易理解的形式

4. 對于指針，盡最大的限度使用const保護它，無論是傳遞給函數(shù)，還是自己使用

先來看看一個特殊的指針，姑且稱它為指針，因為它依賴于環(huán)境: NULL，是一個神奇的東西。先附上定義，在編譯器中會有兩種NULL(每種環(huán)境都有唯一確定的NULL):

#define NULL 0
#define NULL ((void*)0)

有什么區(qū)別嗎？看起來沒什么區(qū)別都是0，只不過一個是常量，一個是地址為0的指針。

當它們都作為指針的值時并不會報錯或者警告，即編譯器或者說C標準認為這是合法的:

int* temp_int_1 = 0; //無警告
int* temp_int_2 = (void*)0; //無警告
int* temp_int_3 = 10; //出現(xiàn)警告

為什么？為什么0可以賦值給指針，但是10卻不行？他們都是常量。

因為C語言規(guī)定當處理上下文的編譯器發(fā)現(xiàn)常量0出現(xiàn)在指針賦值的語句中，它就作為指針使用，似乎很扯淡，可是卻是如此。

回到最開始，對于NULL的兩種情況，會有什么區(qū)別？拿字符串來說，實際上我是將字符數(shù)組看作是C風格字符串。

在C語言中，字符數(shù)組是用來存儲一連串有意義的字符，默認在這些字符的結(jié)尾添加'\0'，好這里又出現(xiàn)了一個0值。

對于某些人，在使用字符數(shù)組的時候總是分不清楚NULL與'\0'的區(qū)別而誤用，在字符數(shù)組的末尾使用NULL是絕對錯誤的！雖然它們的本質(zhì)都是常量0，但由于位置不同所以含義也不同。

開胃菜已過

對于一個函數(shù)，我們進行參數(shù)傳遞，參數(shù)有兩種形式: 形參與實參

int function(int value)
{
        /*...*/
}
//...
function(11);

其中，value是形參，11是實參，我們知道場面上，C語言擁有兩種傳遞方式:按值傳遞和按址傳遞，但是你是否有認真研究過？這里給出一個實質(zhì)，其實C語言只有按值傳遞，所謂按址傳遞只不過是按值傳遞的一種假象。至于原因稍微一想便能明白。

對于形參和實參而言兩個關系緊密，可以這么理解總是實參將自己的一份拷貝傳遞給形參，這樣形參便能安全的使用實參的值，但也帶給我們一些麻煩，最經(jīng)典的交換兩數(shù)

void swap_v1(int* val_1, int* val_2)
{
    int temp = *val_1;
    *val_1 = *val_2;
    *val_2 = *val_1;
}

這就是所謂的按址傳遞，實際上只是將外部指針(實參)的值做一個拷貝，傳遞給形參val_1與val_2，實際上我們使用:

#define SWAP_V2(a, b) (a += b, b = a - b, a -= b)
#define SWAP_V3(x, y) {x ^= y; y ^= x; x ^= y}

試一試是不是很神奇，而且省去了函數(shù)調(diào)用的時間，空間開銷。上述兩種寫法的原理實質(zhì)是一樣的。

但是，動動腦筋想一想，這種寫法真的沒有瑕疵嗎？如果輸入的兩個參數(shù)本就指向同一塊內(nèi)存，會發(fā)生什么？

...
int test_1 = 10, test_2 = 100;
SWAP_V2(test_1, test_2);                    
printf("Now the test_1 is %d, test_2 is %d\n", test_1, test_2);
.../*恢復原值*/
SWAP_V2(test_1, test_1);
printf("Now the test_1 is %d\n", test_1);   

會輸出什么？:

$: Now the test_1 is 100, test_2 is 10
$: Now the test_1 is 0

對，輸出了0，為什么？稍微動動腦筋就能相通，那么對于后面的SWAP_V3亦是如此，所以在斟酌之下，解決方案應該盡可能短小精悍:

static inline void swap_final(int* val_1, int* val_2)
{
    if(val_1 == val_2)
        return;
    *val_1 ^= *val_2;
    *val_2 ^= *val_1;
    *val_1 ^= *val_2;
}
#define SWAP(x, y) \
do{                 \
    if(&x == &y)    \
        break;      \
    x ^= y;     \
    y ^= x;     \
    x ^= y;     \
}while(0)

這便是目前能找到最好的交換函數(shù)，我們在此基礎上可以考慮的更深遠一些，如何讓這個交換函數(shù)更加通用？即適用范圍更大？暫不考慮浮點類型。 提示：可用void*

與上面的情況類似，偶爾的不經(jīng)意就會造成嚴重的后果:

int combine_1(int* dest, int* add)
{
    *dest += *add;
    *dest += *add;
    return *dest;
}
int combine_2(int* dest, int* add)
{
    *dest += 2 * (*add);//在不確定優(yōu)先級時用括號是一個明智的選擇
    return *dest;
}

上述兩個函數(shù)的功能一樣嗎？恩看起來是一樣的

int test_3 = 10, test_4 = 100;

combine_1(&test_3, &test_4);
printf("After combine_1, test_3 = %d\n",test_3);
.../*恢復原值*/
combine_2(&test_3, &test_4);
printf("After combine_2, test_3 = %d\n",test_3);

輸出

$: After combine_1, test_3 = 210

$: After combine_2, test_3 = 210

如果傳入兩個同一對象呢？

... /*恢復test_3原值*/
combine_1(&test_3, &test_3);
printf("After second times combine_1, test_3 = %d\n",test_3);
...
combine_2(&test_3, &test_3);
printf("After second times combine_2, test_3 = %d\n",test_3);

輸出

$: After second times combine_1, test_3 = 40

$: After second times combine_2, test_3 = 30

知道真相總是令人吃驚，指針也是那么令人又愛又恨。

• C99 標準之后出現(xiàn)了一個新的關鍵字， restrict，被用于修飾指針，它并沒有太多的顯式作用，甚至加與不加，在 你自己 看來，效果毫無區(qū)別。但是反觀標準庫的代碼中，許多地方都使用了該關鍵字，這是為何
  • 首先這個關鍵字是寫給編譯器看的
  • 其次這個關鍵字的作用在于輔助編譯器更好的優(yōu)化該程序(后方文章會有介紹)
  • 最后，如果不熟悉，絕對不要亂用這個關鍵字。

關于數(shù)組的那些事

數(shù)組和指針一樣嗎？

不一樣

要時刻記住，數(shù)組與指針是不同的東西。但是為什么下面代碼是正確的？

int arr[10] = {10, 9, 8, 7};
int* parr  = arr;

我們還是那句話，結(jié)合上下文，編譯器推出 arr處于賦值操作符的右側(cè)，默默的將他轉(zhuǎn)換為對應類型的指針，而我們在使用arr時也總是將其當成是指向該數(shù)組內(nèi)存塊首位的指針。

//int function2(const int test_arr[10]
//int function2(const int test_arr[]) 考慮這三種寫法是否一樣
int function2(const int* test_arr)
{
    return sizeof(test_arr);
}
...
int size_out = sizeof(arr);
int size_in  = function2(arr);

printf("size_out = %d, size_in = %d\n", size_out, size_in);

輸出: size_out = 40, size_in = 8

這就是為什么數(shù)組與指針不同的原因所在，在外部即定義數(shù)組的代碼塊中，編譯器通過上下文發(fā)覺此處arr是一個數(shù)組，而arr代表的是一個指向10個int類型的數(shù)組的指針，只所謂最開始的代碼是正確的，只是因為這種用法比較多，就成了標準的一部分。就像世上本沒有路，走的多了就成了路。"正確"的該怎么寫

int (*p)[10] = &arr;

此時p的類型就是一個指向含有10個元素的數(shù)組的指針,此時(*p)[0]產(chǎn)生的效果是arr[0]，也就是parr[0]，但是(*p)呢？這里不記錄，結(jié)果是會溢出，為什么？

這就是數(shù)組與指針的區(qū)別與聯(lián)系，但是既然我們可以使用像parr這樣的指針，又為什么要寫成int (*p)[10]這樣丑陋不堪的模式呢？原因如下:

• 回到最開始說過的傳遞方式，按值傳遞在傳遞arr時只是純粹的將其值進行傳遞，而丟失了上下文的它只是一個普通指針，只不過我們程序員知道它指向了一塊有意義的內(nèi)存的起始位置，我想要將數(shù)組的信息一起傳遞，除了額外增加一個參數(shù)用來記錄數(shù)組的長度以外，也可以使用這個方法，傳遞一個指向數(shù)組的指針 這樣我們就能只傳遞一個參數(shù)而保留所有信息。但這么做的也有限制:對于不同大小，或者不同存儲類型的數(shù)組而言，它們的類型也有所不同

    int arr_2[5];
    int (*p_2)[5] = &arr_2;
    float arr_3[5];
    float (*p_3)[5] = &arr_3;

  如上所示，指向數(shù)組的指針必須明確指定數(shù)組的大小，數(shù)組存儲類型，這就讓指向數(shù)組的指針有了比較大的限制。

• 這種用法在多維數(shù)組中使用的比較多，但總體來說平常用的并不多，就我而言，更傾向于使用一維數(shù)組來表示多維數(shù)組，實際上誠如前面所述，C語言是一個非常簡潔的語言，它沒有太多的廢話，就本質(zhì)而言C語言并沒有多維數(shù)組，因為內(nèi)存是一種線性存在，即便是多維數(shù)組也是實現(xiàn)成一維數(shù)組的形式。

  • 就多維數(shù)組在這里解釋一下。所謂多維數(shù)組就是將若干個降一維的數(shù)組組合在一起，降一維的數(shù)組又由若干個更降一維的數(shù)組組合在一起，直到最低的一維數(shù)組，舉個例子:

    int dou_arr[5][3];

    就這個二維數(shù)組而言，將5個每個為3個int類型的數(shù)組組合在一起，要想指向這個數(shù)組該怎么做？

        int (*p)[3]        = &dou_arr[0];
        int (*dou_p)[5][3] = &dou_arr;
        int (*what_p)[3]   = dou_arr;

    實際上多維數(shù)組只是將多個降一維的數(shù)組組合在一起，令索引時比較直觀而已。當真正理解了內(nèi)存的使用，反而會覺得多維數(shù)組帶給自己更多限制 對于第三句的解釋，當數(shù)組名出現(xiàn)在賦值號右側(cè)時，它將是一個指針，類型則是 指向該數(shù)組元素的類型，而對于一個多維數(shù)組來說，其元素類型則是其降一維數(shù)組，即指向該降一維數(shù)組的指針類型。這個解釋有點繞，自己動手寫一寫就好很多。

對于某種形式下的操作，我們總是自然的將相似的行為結(jié)合在一起考慮?？紤]如下代碼:

int* arr_3[5] = {1, 2, 3, 4, 5};
int* p_4      = arr_3;

printf("%d == %d == %d ?\n", arr_3[2], *(p_4 + 2), *(arr_3 + 2));

輸出: 3 == 3 == 3 ? 實際上對于數(shù)組與指針而言， []操作在大多數(shù)情況下都能有相同的結(jié)果，對于指針而言*(p_4 + 2)相當于p_4[2]，也就是說[]便是指針運算的語法糖，有意思的是2[p_4]也相當于p_4[2]，"Iamastring"[2] == 'm'，但這只是娛樂而已，實際中請不要這么做，除非是代碼混亂大賽或者某些特殊用途。 在此處，應該聲明的是這幾種寫法的執(zhí)行效率完全一致，并不存在一個指針運算便快于[]運算，這些說法都是上個世紀的說法了，隨著時代的發(fā)展，我們應該更加注重代碼整潔之道

在此處還有一種奇異又實用的技巧，在char數(shù)組中使用指針運算進行操作，提取不同類型的數(shù)據(jù)，或者是在不同類型數(shù)組中，使用char*指針抽取其中內(nèi)容，才是顯示指針運算的用途。但在使用不同類型指針操作內(nèi)存塊的時候需要注意，不要操作無意義的區(qū)域或者越界操作。

實際上，最簡單的安全研究之一，便是利用溢出進行攻擊。

Advance:對于一個函數(shù)中的某個數(shù)組的增長方向，總是向著返回地址的，中間可能隔著許多其他自動變量，我們只需要一直進行溢出試驗，直到某一次，該函數(shù)無法正常返回了！那就證明我們找到了該函數(shù)的返回地址存儲地區(qū)，這時候我們可以進行一些操作，例如將我們想要的返回地址覆蓋掉原先的返回地址，這就是所謂的溢出攻擊中的一種。