類與物件：

const常量哪怕棧空間資料被改 被訪問時依然是使用存於符號表的資料

建構函式的形式:
拷貝構造 Test(Test &t){}
初始化構造 Test(int d): data(d){}

   Test t(10);
   t = 200;    
   //只要型別不同，會建立一箇中間的無名變數來賦值；
   //實際上是呼叫了建構函式中的 Test(200) 建立了一個物件，將物件賦值給t；
   //如果建構函式中使用explicit作為修飾，不能隱式轉化時，會杜絕這種情況發生；
   //上一行的情況則必須 使用：   t = (Test) 200;

   Test t1 = t2;       //拷貝構造
 

   Test t1; t1 = t2;   //運算子過載賦值

拷貝構造： 形如 void fun(Test a);
如果函式的引數是以傳入物件的形式， 那麼傳入物件的時候會進行一次拷貝構造

     返回值是物件的時候： Test fun(int a)
                         {
                             Test new_one(a);
                             return new_one;
                         }
如果編譯器做了優化 可能會延長返回物件的生存週期 而不是重新拷貝構造一個無名物件來返回
 

*拷貝構造的時候要考慮淺拷貝和深拷貝的問題

         注意： 區域性物件不能以引用形式返回，區域性物件會被銷燬

*拷貝構造的引數最好使用const修飾 比如Test(const Test &t)(…)
因為return的時候可能會檢測到拷貝建構函式，而return返回的物件具有常性，需要const屬性

賦值函式的編寫：
1.自身賦值問題
2.釋放原有記憶體的空間
3.開闢空間深拷貝賦值資料
4.返回自身物件
—- Tip：異常安全問題 在賦值期間發生異常 保證賦值兩者的資料安全

*類成員有指標的時候 考慮拷貝構造和析構還有運算子過載的安全性

vld.h: 檢測記憶體洩露的庫

Question: C++的類的初始的函式有六個 分別是什麼？
explicit關鍵字的用法？
如何把一個只有一個數據成員的物件直接給一個該資料的變數賦值？(Test t(200); int value = t;)

成員函式中用const修飾的方法：
void Test::fun()const;
實際上相當於
void Test::fun(const Test * const this);
本質上就是不能修改this所指的物件的值;
***tips： 常方法不能呼叫有可能改變物件的值的成員函式；

成員函式中的static修飾的方法：
static修飾的變數以及函式，被所有物件共享，沒有this指標；
***tips： 靜態方法不能呼叫成員函式，因為它是被所有類物件共享的；

用friend關鍵字修飾的友元函式可以訪問私有成員；
— 常用來過載流運算子；

運算子過載：

   **不能使用的過載運算子：**
       三目運算子： ?:
       成員訪問符： . .*
       字長訪問符： sizeof
       作用域符：   ::

++運算子的過載：

    前置++: Test operator++();
    後置++: Test operator++(int);
        此處的int僅作為標記使用；

流運算子過載：

   friend ostream& operator<<(ostream &out, const Test &t);
   {
       out << t.data;
       return out;
   }

作為友元函式進行過載；

C++如何實現的過載：

   編譯器在彙編階段根據函式的引數通過自己的一套命名方式
   將函式進行一系列重新命名，翻譯成另一個具有唯一性的名字(帶上函式的引數)

   當加入extern "C" 修飾函式的時候用C的模式彙編

空間分配(new && delete):

new 等同於 C 語言中的 (強制轉化 *)malloc(sizeof(型別));

   int *p   = new int(10);     //新建一個值為10的整形
   int *p   = new int[10];     //新建一個有10個成員的整形陣列

   int *p   = new Test;        //呼叫建構函式申請空間(如果要求有引數必須寫引數)

   int *p   = new Test[10];    //構造10個物件！
                               //Tips: 如果要直接構造，一定要有預設(帶參)的建構函式
   delete []p;                 //*** 通過delete刪除掉連續申請的物件空間 否則記憶體洩露
       //方括號只起到標記作用，標識是釋放一個數組空間

new的步驟：
1.申請空間；
2.呼叫建構函式在申請的空間內構造物件；

delete的步驟：
1.呼叫解構函式析構物件；
2.釋放空間；

模板：

   #include <typeinfo>
   template<typename Type>
   Max(Type a, Type b)
   {
       cout<<typeid(Type).name()<<endl;
       //打印出Type的型別
       return a>b ? a:b;
   }

實現是先通過一系列操作與函式模板， 製作出相應型別的模板函式
最後再用模板函式來實現函式功能

類的形式類似;

可以直接呼叫：
Max(1,2);
Max(‘A’, ‘X’);
或者顯式呼叫：
Max(1,2);
Max(‘A’, ‘X’);

Gdb除錯：

1.g++ -o -g
2.gdb
3.list
4.b 加斷點
5.run

new && delete:

1.new operator -> 1)分配空間 2)建構函式

              (直接使用 new 關鍵字)

2.operator new -> 只分配空間

              (直接使用 operator new 關鍵字)

可以過載new操作符來影響其分配空間的操作

   void *operator new(size_t sz)
   {
       void *p = malloc(sz);
       return p;
   }

要求返回值void * 傳入引數 size_t

同時如果你過載了new操作符，就要求你過載delete操作符

   void operator delete(void *p)
   {
       free(p);
   }

*Tips:free 與 malloc對應
new 與 delete對應
operator new 與 operator delete 對應

同理 new[] 與 delete[] 也可以過載
實際上new[] 在申請空間的時候，
頭部會多出一部分cookie空間， 大小為一個指標的大小
儲存著使用者的資訊：起始位置，釋放多少個物件
此時才可以以delete[]來釋放相應的空間

類裡面也可以過載new delete操作符，而且會被物件優先使用

如果是void*p = new Test(10);
那麼delete p的時候 不會呼叫類的解構函式;

3.placement new

通過malloc開闢空間之後
int p = (int )malloc(sizeof(int) * 10)
可以通過new(p)int(10)來對申請的空間進行賦值
這種語法稱之為定位new

這樣的new也是可以過載的：

   void *operator new(size_t sz, void *data, int pos)
   {
       return (data + pos);
   }

則使用方法變為

new(p, 3)int(200);

對p所指的第三個位置進行賦值200的操作

繼承和多型：

子類雖然公有繼承了基類的私有成員
但是依然不能在自己的方法中改變基類
正確的用法是在基類中設定相應的設定方法來設定基類的成員

父類的資訊能否被子類調動？

   ***父類任意私有資料都不能被子類直接呼叫
   但是父類的公有方法與保護方法都可以被子類的方法呼叫
   只有公有方法可以被物件直接訪問

保護方法存在的意義：

   ***保護只在繼承的時候體現它的性質
   不想被外部的物件呼叫， 為了給子類提供藉口而存在
   其他一切特點等同於私有

class C: D
預設是私有繼承 (class C: private D)

多繼承：

   多繼承的建構函式順序就是繼承列表從左往右
   同時先構造成員的類物件再構造自身類物件
   建構函式書寫方法：
   C(a, b, c): A(a), B(b), C(c){}
   子類要呼叫基類的構造方法

   二義性：
       父類有同名的變數
       那麼需要通過加入 父類:: 來避免二義性

虛繼承：

   可以避免繼承同一個基類產生變數的二義性

同名隱藏：

   如果子類和父類有同名的方法
   那麼父類的同名方法會完全被隱藏(哪怕是過載)
   但是可以通過使用::這個來直接呼叫父類方法

看書：
1.過載 2.覆蓋 3.隱藏