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

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