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