《c++入門經典》筆記10

第十章 創建指針

10.1理解指針及其用途

變數是可存儲一個值的對象：整型變數存儲一個數字，字元變數存儲一個字母，而指針是存儲記憶體地址的變數。

電腦記憶體是存儲變數值的地方。根據約定，電腦記憶體被劃分成按順序編號的記憶體單元，每個記憶體單元都有對應的地址。記憶體中，不管其類型是什麼，每個變數都位於特定的地址處。

記憶體編址方案隨電腦而異。通常，程式員無須知道變數地址，如果想要獲取地址信息，可使用地址運算符&

程式清單10.1 Address.cpp

#include<iostream>

int main()
{
    unsigned short shortVar = 5;
    unsigned long longVar = 65535;
    long sVar = -65535;

    std::cout<<"shortVar:\t"<<shortVar;
    std::cout<<"\tAddress of shortVar:\t"<<&shortVar<<"\n";
    std::cout<<"longVar:\t"<<longVar;
    std::cout<<"\tAddress of longVar:\t"<<&longVar<<"\n";
    std::cout<<"sVar:\t"<<sVar;
    std::cout<<"\tAddress of sVar:\t"<<&sVar<<"\n";

}

(地址預設以16進位表示法輸出的)

您運行該程式時，變數的地址將不同，因為這取決於記憶體中存儲的其他內容以及可用的記憶體有多少。

在指針中存儲地址

每個變數都有地址，即使不知道變數的具體地址，也可將該地址存儲在指針變數中。

int howOld = 50;
int* pAge = nullptr;//初始化一個int型空指針變數，這樣能更明顯看出來pAge類型是int*，但c/c++的標準寫法是int *pAge
pAge = &howOld;//將howOld的地址取出來放入指針變數pAge中

間接運算符

間接運算符（*）又被稱為解引用運算符。對指針解除引用時，將獲取指針存儲的地址處的值。

int howOld = 50;
int* pAge = &howOld;
int yourAge;
yourAge = *pAge;//yourAge的值變成了50
*pAge = 10;//howOld的值變成了10，而yourAge的值還是50

指針pAge前面的間接運算符(*)表示“存儲在......處的值”。這條賦值語句的意思是，從pAge指向的地址處獲取值，並將其賦給yourAge。看待這條語句的另一種方式是，不影響指針，而是影響指針指向的內容（比如上面最後一條語句）。

使用指針操作數據（其實上面那個例子就是）

程式清單10.2 Pointer.cpp

#include <iostream>

int main()
{
    int myAge;
    int *pAge = nullptr;

    myAge = 5;
    pAge = &myAge;
    std::cout << "myAge: " << myAge << "\n";
    std::cout << "*pAge: " << *pAge << "\n\n";

    std::cout << "*pAge = 7\n";
    *pAge = 7;
    std::cout << "myAge: " << myAge << "\n";
    std::cout << "*pAge: " << *pAge << "\n\n";

    std::cout << "myAge = 9\n";
    myAge = 9;
    std::cout << "myAge: " << myAge << "\n";
    std::cout << "*pAge: " << *pAge << "\n";
}

查看存儲在指針中的地址：

程式清單10.3 PointerCheck.cpp

#include <iostream>

int main()
{
    unsigned short int myAge = 5, yourAge = 10;
    unsigned short int *pAge = &myAge;

    std::cout << "pAge: " << pAge << "\n";
    std::cout << "*pAge: " << *pAge << "\n";

    pAge = &yourAge;
    std::cout << "after reassign the pAge point to yourAge : "
              << "\n";
    std::cout << "pAge: " << pAge << "\n";
    std::cout << "*pAge: " << *pAge << "\n";

    return 0;
}

為何使用指針

熟悉指針的語法後，便可將其用於其他用途了，指針最長用於完成如下三項任務：

• 管理堆中的數據；
• 訪問類的成員數據和成員函數；
• 按引用將變數傳遞給函數

10.2堆和棧

（這部分其實如果有一點數據結構或者操作系統基礎更好）

程式員通常需要處理下述五個記憶體區域

• 全局名稱空間
• 堆
• 寄存器
• 代碼空間
• 棧

局部變數和函數參數存儲在棧中，代碼當然在代碼空間中，而全局變數在全局名稱空間中。寄存器用於記憶體管理，如跟蹤棧頂和指令指針，幾乎餘下的所有記憶體都分配給了堆，堆有時也被稱為自由存儲區。

局部變數的局限性是不會持久化，函數返回時，局部變數將被丟棄。全局變數解決了這種問題，但代價是在整個程式中都能訪問它，這導致代碼容易出現bug，難以理解與維護。將數據放在堆中可解決這兩個問題。

每當函數返回時，都會清理棧（實際上，開始調用函數時，棧空間進行壓棧操作；函數調用完時，棧空間進行出棧操作）。此時，所有的局部變數都不在作用域內，從而從棧中刪除。只有到程式結束後才會清理堆，因此使用完預留的記憶體後，您需要負責將其釋放（手動GC）。讓不再需要的信息留在堆中稱為記憶體泄露（垃圾滯留）。

堆的優點在於，在顯示釋放前，您預留的記憶體始終可用。如果在函數中預留堆中的記憶體，在函數返回後，該記憶體仍可用。

以這種方式（而不是全局變數）訪問記憶體的優點是，只有有權訪問指針的函數才能訪問它指向的數據。這提供了控制嚴密的數據介面，消除了函數意外修改數據的問題。

關鍵字new

在c++中，使用new關鍵字分配堆中的記憶體，併在其後指定要為之分配記憶體的對象的類型，讓編譯器知道需要多少記憶體。比如new int分配4位元組記憶體。

關鍵字new返回一個記憶體地址，必須將其賦給指針。

int *pPointer = new int;//指針pPointer將指向堆中的一個int變數
*pPointer = 72;//將72賦值給pPointer指向的堆記憶體變數

關鍵字delete

使用好了分配的記憶體區域後，必須對指針調用delete，將記憶體歸還給堆空間。

delete pPointer;

對指針調用delete時，將釋放它指向的記憶體。如果再次對該指針調用delete，就會導致程式崩潰（delete野指針）。刪除指針時，應將其設置為nullptr，對空指針調用delete是安全的。

Animal *pDog = new Animal;
delete pDog;//釋放記憶體
pDog = nullptr;//設置空指針
delete pDog;//安全行為

程式清單10.4 Heap.cpp

#include <iostream>

int main()
{
    int localVariable = 5;
    int *pLocal = &localVariable;
    int *pHeap = new int;
    if (pHeap == nullptr)
    {
        std::cout << "Error! No memory for pHeap!!";
        return 1;
    }
    *pHeap = 7;
    std::cout << "localVariable: " << localVariable << std::endl;
    std::cout << "*pLocal: " << *pLocal << std::endl;
    std::cout << "*pHeap: " << *pHeap << std::endl;
    delete pHeap; //此處只是釋放了堆中new分配的記憶體，並沒有刪除指針，所以下麵可以接著用。
    pHeap = new int;
    if (pHeap == nullptr)
    {
        std::cout << "Error! No memory for pHeap!!";
        return 1;
    }
    *pHeap = 9;
    std::cout << "*pHeap: " << *pHeap << std::endl;
    delete pHeap; //再次釋放new出來的記憶體
    return 0;
}

另一種可能無意間導致記憶體泄露的情形是，沒有釋放指針指向的記憶體就給它重新賦值。

int *pPointer = new int;
*pPointer = 72;
pPointer = new int;
*pPointer = 50;//指針變數指向了一個新new出來的存有50的int型變數，但是之前那個存有72的堆記憶體變數還沒被釋放，也就造成了記憶體泄露

上述代碼應該修改成這樣：

int *pPointer = new int;
*pPointer = 72;
delete pPointer;
pPointer = new int;
*pPointer = 50;

也就是說一個不存在記憶體泄露的c++程式至少其new與delete是成對的，或者說是數量相等的。（這可苦了c艹程式員咯！）

空指針常量：

在較早的c++版本中，使用0或者NULL來設置指針為空值。

int *pBuffer = 0;
int *pBuffer = NULL;

但是其實因為定義NULL的語句是一個預處理巨集：

#define NULL 0

所以其實NULL和0一個意思，上面兩句也是一個意思。

但是當某個函數進行了重載，參數有指針類型也有int型的時候，傳了一個值為0的空值指針進去，這個時候會出現二義性：

void displayBuffer(char*);//這個函數的參數是char型指針變數
void displayBuffer(int);

如果將空指針作為參數去調用，那麼會調用displayBuffer(int)，這個時候就會造成運行與預期不同。

所以才應該使用關鍵字nullptr

int *pBuffer = nullptr;

程式清單10.5 Swapper.cpp

#include <iostream>

int main()
{
    int value1 = 12500;
    int value2 = 1700;
    int *pointer2 = nullptr;
    pointer2 = &value2;
    value1 = *pointer2;
    pointer2 = 0;
    std::cout << "value = " << value1 << "\n";

    return 0;
}