使用弱引用的智能指針weak_ptr打破這種循環(huán)引用。為了解決循環(huán)引用導致的內(nèi)存泄漏，引入了weak_ptr 弱指針，weak_ptr 的構造函數(shù)不會修改引用計數(shù)的值，從而不會對對象的內(nèi)存進行管理，其類似一個普通指針，但不指向引用計數(shù)的共享內(nèi)存，但是其可以檢測到所管理的對象是否已經(jīng)被釋放，從而避免非法訪問。

5.6 shared_ptr的實現(xiàn)

template <typename T>
class SmartPtr
{
private:
    T *ptr; //底層真實的指針
    int *use_count;//保存當前對象被多少指針引用計數(shù)
public:
    SmartPtr(T *p); //SmartPtrp(new int(2));
    SmartPtr(const SmartPtr&orig);//SmartPtrq(p);
    SmartPtr&operator=(const SmartPtr &rhs);//q=p
    ~SmartPtr();
    T operator*(); //為了能把智能指針當成普通指針操作定義解引用操作
    T*operator->(); //定義取成員操作
    T* operator+(int i);//定義指針加一個常數(shù)
    int operator-(SmartPtr&t1, SmartPtr&t2);//定義兩個指針相減
    void getcount()
    {
        return *use_count
    }
};

template <typename T>
int SmartPtr::operator-(SmartPtr &t1, SmartPtr &t2)
{
    return t1.ptr - t2.ptr;
}
template <typename T>
SmartPtr::SmartPtr(T *p)
{
    ptr = p;
    try
    {
        use_count = new int(1);
    }
    catch (...)
    {
        delete ptr; //申請失敗釋放真實指針和引用計數(shù)的內(nèi)存
        ptr = nullptr;
        delete use_count;
        use_count = nullptr;
    }
}
template <typename T>
SmartPtr::SmartPtr(const SmartPtr &orig) //復制構造函數(shù)
{
    use_count = orig.use_count;//引用計數(shù)保存在一塊內(nèi)存，所有的 SmarPtr 對象的引用計數(shù)
    都指向這里
        this->ptr = orig.ptr;
    ++(*use_count); //當前對象的引用計數(shù)加 1
}
template <typename T>
SmartPtr& SmartPtr::operator=(const SmartPtr &rhs)
{
    //重載=運算符，例如 SmartPtrp,q; p=q;這個語句中，首先給 q 指向的對象的引用計數(shù)加1，因為 p 重新指向了 q 所指的對象，所以 p 需要先給原來的對象的引用計數(shù)減 1，如果減一后為 0，先釋放掉 p 原來指向的內(nèi)存，然后講 q 指向的對象的引用計數(shù)加 1 后賦值給 p
    ++*(rhs.use_count);
    if ((--*(use_count)) == 0)
    {
        delete ptr;
        ptr = nullptr;
        delete use_count;
        use_count = nullptr;
    }
    ptr = rhs.ptr;
    *use_count = *(rhs.use_count);
    return *this;
}
template <typename T>
SmartPtr::~SmartPtr()
{
    getcount();
    if (--(*use_count) == 0) //SmartPtr 的對象會在其生命周期結(jié)束的時候調(diào)用其析構函數(shù)，在析構函數(shù)中檢測當前對象的引用計數(shù)是不是只有正在結(jié)束生命周期的這個 SmartPtr 引用，如果是，就釋放掉，如果不是，就還有其他的 SmartPtr 引用當前對象，就等待其他的 SmartPtr對象在其生命周期結(jié)束的時候調(diào)用析構函數(shù)釋放掉
    {
        getcount();
        delete ptr;
        ptr = nullptr;
        delete use_count;
        use_count = nullptr;
    }
}
template <typename T>
T SmartPtr::operator*()
{
    return *ptr;
}
template <typename T>
T* SmartPtr::operator->()
{
    return ptr;
}
template <typename T>
T* SmartPtr::operator+(int i)
{
    T *temp = ptr + i;
    return temp;
}

6 數(shù)組和指針

7 野指針

野指針就是指向一個已刪除的對象或者未申請訪問受限內(nèi)存區(qū)域的指針

8 函數(shù)指針

8.1 定義

函數(shù)指針是指向函數(shù)的指針變量。

函數(shù)指針本身首先是一個指針變量，該指針變量指向一個具體的函數(shù)。這正如用指針變量可指向整型變量、字符型、數(shù)組一樣，這里是指向函數(shù)。

C 在編譯時，每一個函數(shù)都有一個入口地址，該入口地址就是函數(shù)指針所指向的地址。有了指向函數(shù)的指針變量后，可用該指針變量調(diào)用函數(shù)，就如同用指針變量可引用其他類型變量一樣，在這些概念上是大體一致的。

8.2 用途：

調(diào)用函數(shù)和做函數(shù)的參數(shù)，比如回調(diào)函數(shù)。

8.3 示例：

char * fun(char * p) {…}   // 函數(shù) fun
char * (*pf)(char * p);    // 函數(shù)指針 pf
pf = fun;                  // 函數(shù)指針 pf 指向函數(shù) fun
pf(p);                     // 通過函數(shù)指針 pf 調(diào)用函數(shù) fun

9 fork函數(shù)

Fork：創(chuàng)建一個和當前進程映像一樣的進程可以通過 fork( )系統(tǒng)調(diào)用：

#include 
#include 
pid_t fork(void);

成功調(diào)用 fork( )會 創(chuàng)建一個新的進程 ，它幾乎與調(diào)用 fork( )的進程一模一樣，這兩個進程都會繼續(xù)運行。在子進程中，成功的 fork( )調(diào)用會返回 0。在父進程中 fork( )返回子進程的 pid。如果出現(xiàn)錯誤，fork( )返回一個負值。

最常見的 fork( )用法是創(chuàng)建一個新的進程，然后使用 **exec( )**載入二進制映像，替換當前進程的映像。這種情況下，派生（fork）了新的進程，而這個子進程會執(zhí)行一個新的二進制可執(zhí)行文件的映像。這種“派生加執(zhí)行”的方式是很常見的。

在早期的 Unix 系統(tǒng)中，創(chuàng)建進程比較原始。當調(diào)用 fork 時，內(nèi)核會把所有的內(nèi)部數(shù)據(jù)結(jié)構復制一份，復制進程的頁表項，然后把父進程的地址空間中的內(nèi)容逐頁的復制到子進程的地址空間中。但從內(nèi)核角度來說，逐頁的復制方式是十分耗時的?，F(xiàn)代的 Unix 系統(tǒng)采取了更多的優(yōu)化，例如 Linux，采用了寫時復制的方法，而不是對父進程空間進程整體復制。

10 析構函數(shù)

析構函數(shù)與構造函數(shù)對應，當對象結(jié)束其生命周期，如對象所在的函數(shù)已調(diào)用完畢時，系統(tǒng)會自動執(zhí)行析構函數(shù)。

析構函數(shù)名也應與類名相同，只是在函數(shù)名前面加一個位取反符~，例如~stud( )，以區(qū)別于構造函數(shù)。它 不能帶任何參數(shù)，也沒有返回值 （包括 void 類型）。只能有一個析構函數(shù)， 不能重載 。

如果用戶沒有編寫析構函數(shù)，編譯系統(tǒng)會自動生成一個缺省的析構函數(shù)（即使自定義了析構函數(shù)，編譯器也總是會為我們合成一個析構函數(shù)，并且如果自定義了析構函數(shù)，編譯器在執(zhí)行時會先調(diào)用自定義的析構函數(shù)再調(diào)用合成的析構函數(shù)），它也不進行任何操作。所以許多簡單的類中沒有用顯式的析構函數(shù)。

如果一個類中有指針，且在使用的過程中動態(tài)的申請了內(nèi)存，那么最好顯示構造析構函數(shù)在銷毀類之前，釋放掉申請的內(nèi)存空間，避免內(nèi)存泄漏。

10.1 類析構順序

1. 派生類本身的析構函數(shù)
2. 對象成員析構函數(shù)
3. 基類析構函數(shù)

因為析構函數(shù)沒有參數(shù)，所以包含成員對象的類的析構函數(shù)形式上并無特殊之處。但在撤銷該類對象的時候，會首先調(diào)用自己的析構函數(shù)，再調(diào)用成員對象的析構函數(shù)，調(diào)用次序與初始化時的次序相反。

11 虛函數(shù)和多態(tài)

多態(tài)的實現(xiàn)主要分為靜態(tài)多態(tài)和 動態(tài)多態(tài) ， 靜態(tài)多態(tài)主要是重載 ，在 編譯的時候就已經(jīng)確定 ；動態(tài)多態(tài)是用虛函數(shù)機制實現(xiàn)的，在 運行期間動態(tài)綁定 。例如：一個父類類型的指針指向一個子類對象時候，使用父類的指針去調(diào)用子類中重寫了的父類中的虛函數(shù)的時候，會調(diào)用子類重寫過后的函數(shù)，在父類中聲明為加了 virtual 關鍵字的函數(shù)，在子類中重寫時候不需要加 virtual也是虛函數(shù)。

虛函數(shù)的實現(xiàn)：在有虛函數(shù)的類中，類的最開始部分是一個虛函數(shù)表的 指針 ，這個指針指向一個 虛函數(shù)表 ，表中放了虛函數(shù)的地址，實際的虛函數(shù)在代碼段(.text)中。當子類繼承了父類的時候也會繼承其虛函數(shù)表，當子類重寫父類中虛函數(shù)時候，會將其繼承到的 虛函數(shù)表中的地址替換為重新寫的函數(shù)地址 。使用了虛函數(shù)，會增加訪問內(nèi)存開銷，降低效率。

12 析構函數(shù)與虛函數(shù)

析構函數(shù)必須是虛函數(shù)，因為將可能會被繼承的父類的析構函數(shù)設置為虛函數(shù)，可以保證當我們 new 一個子類，然后使用基類指針指向該子類對象， 釋放基類指針時可以釋放掉子類的空間 ，防止內(nèi)存泄漏。

C++默認的析構函數(shù)不是虛函數(shù)是因為虛函數(shù)需要額外的虛函數(shù)表和虛表指針，占用額外的內(nèi)存。而對于不會被繼承的類來說，其析構函數(shù)如果是虛函數(shù)，就會浪費內(nèi)存。因此 C++默認的析構函數(shù)不是虛函數(shù)，而是只有當需要當作父類時， 設置虛函數(shù) 。

13 靜態(tài)函數(shù)和虛函數(shù)

靜態(tài)函數(shù)在編譯的時候就已經(jīng)確定運行時機，虛函數(shù)在運行的時候動態(tài)綁定。虛函數(shù)因為用了虛函數(shù)表機制，調(diào)用的時候會增加一次內(nèi)存開銷。

13.1 靜態(tài)函數(shù)

用static修飾的函數(shù)，限定在本源碼文件中使用，不能被本源碼文件以外的代碼文件調(diào)用。 普通的函數(shù)，默認是extern的，也就是說，可以被其它代碼文件調(diào)用該函數(shù)。

13.2 虛函數(shù)表

當一個類中包含被virtual 關鍵字修飾的成員函數(shù)時，該成員函數(shù)就成為了一個 虛函數(shù) 。頭一個含有虛函數(shù)的類所實例化出來的對象都擁有同一個 虛函數(shù)表 ，在對象中含有一個* 虛函數(shù)指針 _vptr ，該指針指向該類的虛函數(shù)表，虛函數(shù)表保存的是類中虛函數(shù)的地址（一個類可能有多個虛函數(shù)）。

13.3 虛函數(shù)作用

當一個子類繼承了一個含有虛函數(shù)的基類，并重寫了該基類中的一個虛函數(shù)，我們就說這兩個類構成多態(tài)。子類繼承基類的同時，基類的虛函數(shù)表也被子類繼承，不同的是被 子類重寫的虛函數(shù)將會替代原來虛函數(shù)表中對應的基類的虛函數(shù)的地址 。從而基類與子類調(diào)用同名的虛函數(shù)時，所調(diào)用的就不是同一個函數(shù)，從而體現(xiàn)了多態(tài)和虛函數(shù)表的作用。

13.4 靜態(tài)函數(shù)與虛函數(shù)的區(qū)別

我們知道類的靜態(tài)函數(shù)是沒有this指針的，調(diào)用它時不需要創(chuàng)建對象，通過：類名 ：：函數(shù)名（參數(shù)）的形式直接調(diào)用。靜態(tài)函數(shù)只有唯一的一份，因此它的 地址是固定不變的 ， 所以編譯的時候但凡遇到調(diào)用該靜態(tài)函數(shù)的時候就知道調(diào)用的是哪一個函數(shù)，因此說靜態(tài)函數(shù)在編譯的時候就已經(jīng)確定運行時機。 而虛函數(shù)則不然，看下面的代碼：

class A
{
	public: 
	virtual void fun()
    {
        cout<<"i am A <I  am  B" <fun();
	return 0; 
}

類A與類B構成多態(tài)，創(chuàng)建了 A類指針pb指向 B類對象，當程序編譯的時候只對語法等進行檢測，該語句沒有什么問題，但是編譯器此時無法確定調(diào)用的是哪一個 fun() 函數(shù)，因為類A類B中都含有fun函數(shù)，因此只能是在程序運行的時候通過 pb指針查看對象的虛函數(shù)表（訪問虛函數(shù)表就是所謂的訪問內(nèi)存）才能確定該函數(shù)的地址，即確定調(diào)用的是哪一個函數(shù)。這就解釋了所說的“ 虛函數(shù)在運行的時候動態(tài)綁定。虛函數(shù)因為用了虛函數(shù)表機制，調(diào)用的時候會增加一次內(nèi)存開銷。 ”

14 重載和覆蓋

14.1 重載

兩個函數(shù)名相同，但是參數(shù)列表不同（個數(shù)，類型），返回值類型沒有要求，在同一作用域中。

14.2 重寫

子類繼承了父類，父類中的函數(shù)是虛函數(shù)，在子類中重新定義了這個虛函數(shù)，這種情況是重寫，是一種同名覆蓋。

15 在main函數(shù)前先運行的函數(shù)

1.test0 ：__attribute((constructor))是gcc擴展，標記這個函數(shù)應當在main函數(shù)之前執(zhí)行。同樣有一個__attribute((destructor))，標記函數(shù)應當在程序結(jié)束之前（main結(jié)束之后，或者調(diào)用了exit后）執(zhí)行。

2.test1 ：全局static變量的初始化在程序初始階段，先于main函數(shù)的執(zhí)行。

#include  
using namespace std;

__attribute((constructor)) void test0()
{
	printf("before main 0\\n");
}

int test1()
{
    cout << "before main 1" << endl;
    return 54;
}

static int i = test1();
int main(int argc, char** argv) 
{
    cout << "main function." <<endl;
    return 0;
}

在leetcode里經(jīng)常見到static，在main之前關閉cin與stdin的同步來“加快”速度的黑科技。

static int _ = []{
    cin.sync_with_stdio(false);
    return 0;
}();

16 內(nèi)存管理

在 C++ 中，虛擬內(nèi)存分為代碼段、數(shù)據(jù)段、BSS 段、堆區(qū)、文件映射區(qū)以及棧區(qū)六部分。

1. 棧(stack) ：程序 自動分配 ，使用?？臻g存儲函數(shù)的返回地址、參數(shù)、局部變量、返回值。
2. 堆(heap) ：

• 堆 ：調(diào)用malloc 在堆區(qū)動態(tài)分配內(nèi)存，調(diào)用 free 來手動釋放。堆是操作系統(tǒng)所維護的一塊特殊內(nèi)存，它提供了動態(tài)分配的功能。
• 自由存儲區(qū) ：由new 分配內(nèi)存，用來 delete 手動釋放。和堆類似，通過new來申請的內(nèi)存區(qū)域可稱為自由存儲區(qū)。

3. 靜態(tài)/全局區(qū) ：在 C++ 里面沒有區(qū)分bss和data。

• bss段 ：存儲未初始化的全局變量和靜態(tài)變量（局部+全局），以及所有被初始化為0的全局變量和靜態(tài)變量，Block Started by Symbol。
• data段 ：存儲程序中已初始化的全局變量和靜態(tài)變量。

4. 代碼區(qū) （code segment 或 text segment）：

• 代碼段 ：存放函數(shù)體的二進制代碼，text段。
• 常量區(qū) ：只讀數(shù)據(jù)，比如字符串常量，程序結(jié)束時由系統(tǒng)釋放。 rodata段 ，read only。

init段：程序初始化入口代碼，在main() 之前運行。

17 常量const

常量是固定值，在程序執(zhí)行期間不會改變。常量可以是任何的基本數(shù)據(jù)類型，可分為int、float、char、string和bool。常量定義必須初始化。

17.1 存儲區(qū)域

1. 局部常量 ，存放在 棧區(qū) ；
2. static/全局常量 ，存放在 靜態(tài)/全局存儲區(qū) ；
3. 字面值常量 ，其值一望而知，存放在 常量區(qū) 。

17.2 const修飾成員函數(shù)

const 修飾的成員函數(shù)表明函數(shù)調(diào)用 不會對對象做出任何更改 ，事實上，如果確認不會對對象做更改，就應該為函數(shù)加上 const 限定，這樣無論 const 對象還是普通對象都可以調(diào)用該函數(shù)

若同時定義了兩個函數(shù)，一個帶 const，一個不帶，這相當于函數(shù)的 重載 。

18 代碼解析

18.1 strcpy和strlen

strcpy 是字符串拷貝函數(shù)，原型：

char *strcpy(char* dest, const char *src);

從 src 逐字節(jié)拷貝到 dest，直到遇到'\\0'結(jié)束，因為沒有指定長度，可能會導致拷貝越界，造成緩沖區(qū)溢出漏洞,安全版本是 strncpy 函數(shù)。

strlen 函數(shù)是計算字符串長度的函數(shù)，返回從開始到'\\0'之間的字符個數(shù)。

18.2 ++i和i++

++i 實現(xiàn)：

int& int::operator++（）
{
    *this +=1；
    return *this；
}

i++ 實現(xiàn)：

const int int::operator（int）
{
    int oldValue = *this；
    ++（*this）；
    return oldValue；
}

18.3 代碼的區(qū)別

（1）字符串 123 保存在 常量區(qū) ，const 本來是修飾 arr 指向的值，不能通過 arr 去修改，但是字符串“123”在常量區(qū)，本來就不能改變，所以加不加 const 效果都一樣：

const char * arr = "123";

（2）字符串 123 保存在常量區(qū)，這個 和arr 指針指向的是同一個位置，同樣不能通過 brr 去修改"123"的值：

char * brr = "123";

（3）這里 123 本來是在棧上的，但是編譯器可能會做某些優(yōu)化，將其放到常量區(qū)：

const char crr[] = "123";

（4）字符串 123 保存在 棧區(qū) ，可以通過 drr 去修改：

char drr[] = "123";

19 編程題

19.1 點是在三角形內(nèi)

給定三角形ABC和一點P(x,y,z)，判斷點P是否在ABC內(nèi)。

根據(jù)面積法，如果P在三角形ABC內(nèi)，那么三角形ABP的面積+三角形BCP的面積+三角形ACP的面積應該等于三角形ABC的面積。

S=(x_1y_2+x_2y_3+x_3y_1-x_1y_3-x_2y_1-x_3y_2)/2

代碼如下：

#include 
#include 
using namespace std;
#define ABS_FLOAT_0 0.0001
struct point_float
{
    float x;
    float y;
};

float GetTriangleSquar(const point_float pt0, const point_float pt1, const point_float pt2)  // 計算三角形面積
{
    point_float AB, BC;
    AB.x = pt1.x - pt0.x;
    AB.y = pt1.y - pt0.y;
    BC.x = pt2.x - pt1.x;
    BC.y = pt2.y - pt1.y;
    return fabs((AB.x * BC.y - AB.y * BC.x)) / 2.0f;
}

bool IsInTriangle(const point_float A, const point_float B, const point_float C, const point_float D)  // 判斷給定一點是否在三角形內(nèi)或邊上
{
    float SABC, SADB, SBDC, SADC;
    SABC = GetTriangleSquar(A, B, C);
    SADB = GetTriangleSquar(A, D, B);
    SBDC = GetTriangleSquar(B, D, C);
    SADC = GetTriangleSquar(A, D, C);
    float SumSuqar = SADB + SBDC + SADC;
    if ((-ABS_FLOAT_0 < (SABC - SumSuqar)) && ((SABC - SumSuqar) < ABS_FLOAT_0))
    	return true;
    else
    	return false;
}

19.2 判斷一個數(shù)是二的倍數(shù)

判斷一個數(shù)是不是二的倍數(shù)，即判斷該數(shù)二進制末位是不是 0：

a % 2 == 0  
a & 0x0001 == 0  // 兩種辦法都可

19.3 一個數(shù)中有幾個1

可以直接逐位除十取余判斷：

int fun(long x)
{
    int _count = 0;
    while(x)
    {
        if(x % 10 == 1)
            ++_count;
            x /= 10;
    }
    return _count;
}
int main()
{
    cout << fun(123321) << endl;
    return 0;
}

審核編輯：湯梓紅