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

5.6 shared_ptr的實現

template <typename T>
class SmartPtr
{
private:
    T *ptr; //底層真實的指針
    int *use_count;//保存當前對象被多少指針引用計數
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);//定義指針加一個常數
    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; //申請失敗釋放真實指針和引用計數的內存
        ptr = nullptr;
        delete use_count;
        use_count = nullptr;
    }
}
template <typename T>
SmartPtr::SmartPtr(const SmartPtr &orig) //復制構造函數
{
    use_count = orig.use_count;//引用計數保存在一塊內存，所有的 SmarPtr 對象的引用計數
    都指向這里
        this->ptr = orig.ptr;
    ++(*use_count); //當前對象的引用計數加 1
}
template <typename T>
SmartPtr& SmartPtr::operator=(const SmartPtr &rhs)
{
    //重載=運算符，例如 SmartPtrp,q; p=q;這個語句中，首先給 q 指向的對象的引用計數加1，因為 p 重新指向了 q 所指的對象，所以 p 需要先給原來的對象的引用計數減 1，如果減一后為 0，先釋放掉 p 原來指向的內存，然后講 q 指向的對象的引用計數加 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 的對象會在其生命周期結束的時候調用其析構函數，在析構函數中檢測當前對象的引用計數是不是只有正在結束生命周期的這個 SmartPtr 引用，如果是，就釋放掉，如果不是，就還有其他的 SmartPtr 引用當前對象，就等待其他的 SmartPtr對象在其生命周期結束的時候調用析構函數釋放掉
    {
        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 數組和指針

7 野指針

野指針就是指向一個已刪除的對象或者未申請訪問受限內存區域的指針

8 函數指針

8.1 定義

函數指針是指向函數的指針變量。

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

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

8.2 用途：

調用函數和做函數的參數，比如回調函數。

8.3 示例：

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

9 fork函數

Fork：創建一個和當前進程映像一樣的進程可以通過 fork( )系統調用：

#include 
#include 
pid_t fork(void);

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

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

在早期的 Unix 系統中，創建進程比較原始。當調用 fork 時，內核會把所有的內部數據結構復制一份，復制進程的頁表項，然后把父進程的地址空間中的內容逐頁的復制到子進程的地址空間中。但從內核角度來說，逐頁的復制方式是十分耗時的。現代的 Unix 系統采取了更多的優化，例如 Linux，采用了寫時復制的方法，而不是對父進程空間進程整體復制。

10 析構函數

析構函數與構造函數對應，當對象結束其生命周期，如對象所在的函數已調用完畢時，系統會自動執行析構函數。

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

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

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

10.1 類析構順序

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

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

11 虛函數和多態

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

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

12 析構函數與虛函數

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

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

13 靜態函數和虛函數

靜態函數在編譯的時候就已經確定運行時機，虛函數在運行的時候動態綁定。虛函數因為用了虛函數表機制，調用的時候會增加一次內存開銷。

13.1 靜態函數

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

13.2 虛函數表

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

13.3 虛函數作用

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

13.4 靜態函數與虛函數的區別

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

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

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

14 重載和覆蓋

14.1 重載

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

14.2 重寫

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

15 在main函數前先運行的函數

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

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

#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里經常見到static，在main之前關閉cin與stdin的同步來“加快”速度的黑科技。

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

16 內存管理

在 C++ 中，虛擬內存分為代碼段、數據段、BSS 段、堆區、文件映射區以及棧區六部分。

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

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

3. 靜態/全局區 ：在 C++ 里面沒有區分bss和data。

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

4. 代碼區 （code segment 或 text segment）：

• 代碼段 ：存放函數體的二進制代碼，text段。
• 常量區 ：只讀數據，比如字符串常量，程序結束時由系統釋放。 rodata段 ，read only。

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

17 常量const

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

17.1 存儲區域

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

17.2 const修飾成員函數

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

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

18 代碼解析

18.1 strcpy和strlen

strcpy 是字符串拷貝函數，原型：

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

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

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

18.2 ++i和i++

++i 實現：

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

i++ 實現：

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

18.3 代碼的區別

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

const char * arr = "123";

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

char * brr = "123";

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

const char crr[] = "123";

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

char drr[] = "123";

19 編程題

19.1 點是在三角形內

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

根據面積法，如果P在三角形ABC內，那么三角形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)  // 判斷給定一點是否在三角形內或邊上
{
    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 判斷一個數是二的倍數

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

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

19.3 一個數中有幾個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;
}

審核編輯：湯梓紅