構造，析構，拷貝語義學 semantics of construction destruction and copy

純虛擬函數的存在(Presence of a Pure Virtual Function)

純虛擬函數是可以定義并調用的，只不過只能被靜態調用，不能經由虛擬機制。（經過試驗vs2008是不可以的）

而pure virtual destructor ：class 設計者一定要定義它。因為每一個derived class的destructor會被編譯器加以擴展，以靜態方式調用其每一個virtual base class 以及上層base class 的destructor ，因此缺乏任何一個base class destructor 的定義就會導致連接失敗

基類的析構函數應該設置為虛擬的，不一定是純虛的 ，除非在希望將一個類變成抽象類（不能實例化的類），而這個類又沒有合適的函數可以被純虛化的時候，可以使用純虛的析構函數來達到目的。

class A{ public: char* pChar;A(){pChar=new char[20];};~A(){delete []pChar;}};

class B：public A{ public: char* pChar;B(){pChar=new char[20];}~B(){delete []pChar;}};

int main(){ A* a = new B; delete a;}

如上，如果A的析構函數沒有設置為虛擬的，那么delete a 的時候只有調用了A的析構函數，真正的B并沒有調用。而如果虛擬的話，那么a調用析構函數會調用B的析構函數，而B的析構函數會調用A的析構函數。

虛擬函數的取舍：如果一個函數被設計為虛擬函數，但是他函數定義并不與類型相關，也就是說繼承類改寫他的幾率很低，那么這是個糟糕的事情。如果不是虛擬而且能內聯，這是個很大的損失

---------

沒有繼承下的對象構造

Plain OI’s data 形式

例如 struct {float x,y,z;}

理論上編譯器會生成沒有用的trival ctor dtor copytor copy operator ，然而事實上什么也沒有發生。

全局對象，c中會被放在bss段，而c++中的全局對象會被視為完全定義，被當做初始化過的數據來對待。

抽象數據類型：

class Point {public: Point (float x=0):_x(x){}; private: _x;}

經過封裝的Point class 大小沒有改變 由于默認的member wise 賦值語義已經足夠，我們無需提供copy constructor 和copy operator。對于global 實體，Point::Point(0) 會自動調用 (程序開始時候startup())

如果要對class所有成員都設定常量初值，那么給予一個explicit initial list 會比較高效。

例如 void mumble(){

Point A1={1};

Point A2; A2._x=1;

}

A2的初始化會比A1慢，因為，當activation record（活動記錄 是不是棧中的pc 指針），上述的list中常量就可以放進A1的內存中了

explicit initialzation list （A1的那種）缺點：public 才可以；只能指定常量；

Point *heap = new Point;

翻譯為：

Point *heap = __new(sizeof(Point));

if(heap)heap->Point::Point();

`````

為繼承準備：

class Point{
public:
    Point(float x=0.,float y=0.):_x(x),_y(y){}
    virtual float z();
protected:
    float _x,_y;
};

這里并沒有定義copy constructor ，copy operator，我們所有member 都是數值，因此默認語義下情況良好。virtual destructor 也沒有引入啊，同樣道理，行為良好即可

virtual func 的引入給我們的 Point class 帶來了膨脹作用:

定義的構造函數被附加了一些代碼，用來初始化vptr 這些代碼附加在任何base 初始化之后，任何程序員代碼之前。例如:

Point* Point::Point(Point* this,float x,float y):_x(x),_y(y){

  this->_vptr_Point=_vtbl_Point; this->_x=x;this->_y=y; return this;

}

合成一個copy constructor 和一個 copy operator 而且他們也不再是trival

因為bitwise的賦值可能會帶給vptr 錯誤

···············

繼承體系下的對象構造：

如果定義 T object 會發生什么

1.member initialization list 中的data number 初始化操作會放到ctor 中并以聲明順序排列

2.如果一個member沒有出現在 list 中但他有default constructor ，他必須被調用

3.在那之前，如果class object有vptr 那么他必須設定初值指向正確vtable

4.在那之前，任何上一層base class ctor 必須被調用，以base class 聲明順序，

如果base class 列于 初始化列表中，參數被傳遞

如果base class 不再列表，有默認ctor 調用

如果base class 是多重繼承下 第二或者后繼的base class this 指針調整

5.在那之前virtual base class ctor 必須被調用 從左至右，由深到淺

如果base class 列于 初始化列表中，參數被傳遞如果base class 不再列表，有默認ctor 調用

base class subobject 的offset 必須在執行期可以被存取

··························

虛擬繼承

虛擬繼承比較具有特殊性，因為他具有共享性。在這樣一個繼承體系中

Point 3d 和Vertex 虛擬繼承自Point  ，此時如果按照普通的ctor 規則。Vertex 的ctor 必須調用Point 的ctor ，然而 當  Point3d 和 Vertex 同為Vertex3d的subobject時，他們的調用一定不能發生(this指針的調整問題) ,而只能有 Vertex3d才可以調用，同樣，PVertex構造時候只能由他自己調用，也就是說只有底層的class 完成構建共享的subobject構造。我們可以用一個most _derived參數傳給各個構造函數以指示其是否調用共享部分的ctor。

事實上我們發現，只有當object 是完整object時才會調用共享部分的ctor ，而部分subobject不會調用，從而得到新的策略，提供兩種構造函數一種供完整的object 一種供subobject調用

~~~~vptr 初始化語義學~~~

c++語言告訴我們：在Point3d ctor 調用size函數，必須決議為 point3d  的size 而不是 pvertex的size，可以理解為在ctor和dtor 中虛函數決議為自己的函數，他不虛啦~~~~~(實際上是因為他沒有變身完全)

ctor 調用順序是從根源到末端，從內而外。當base class ctor 執行時候 derived實體還沒有構造出來，在pvertex 構造完整之前，pvertex并不是一個完整的對象，因此只有Point3d subobject構造完畢，這意味著每一個pvertex base class ctor 調用時候，編譯器必須保證有適當的 size 函數實體來調用 how，so 決議為自己的size

另一種方法是控制vptr，

在base class ctor 調用之后，但是在程序員提供代碼或者initial list 之前，我們設定vptr ，也就是說我們保證vptr指向剛剛構造完畢的base clas subobject 對應的vtable ，保證了它能夠調用正確的virtual func；

所以對象構造是這樣的過程：

一個 PVertex對象會先形成一個 Point對象- >Point3d->Vertex->Vertex3d->PVertex

ctor執行算法:

1.derived class ctor 中所有 virtual base class 和上一級base class 調用

2. 上述完成vptr 初始化，指向相應的vtable

3.如果有member initial list 的haunted，將在ctor 展開，這些必須在vptr 設定后進行，防止有virtual func 調用

4.最后執行程序員寫的代碼

vptr 需要被設定的兩種情況：

1.對象完整定義后

2.當一個subobject ctor 調用了一個虛擬函數時候（上面說的很明白嘍）

當聲明一個PVertex對象時候，由于我們對base class ctor 的定義，其vptr 不需要每一個base class ctor 中設定，因此我們可以把ctor 分解成兩部分，一種完整的object  實體，一種subobject實體，subobject實體中vptr 設定可以是省略

如果在class ctor initiallist 調用該class 虛擬函數安全么？ 理論上安全，但是如果依賴未初始化member 不安全

``````````````````

對象復制語義學 object copy semantics

我們有三種選擇：

1 什么都不做，按默認行為實施

2 提供一個explicit copy assignment operator

3 明確拒絕把一個class object 指定給一個class object （聲明一個private 的copy assignment operator）

下列情況下，class 不表現出bitwise 的復制語義，也就是說默認的copy operator 是不夠的：（和之前介紹的一樣）

1.class 有一個member object 而他有copy operator

2.class的base class 有一個copy operator

3.當class 聲明virtual func時 （由于要設定vptr when derived to base）

4.class 繼承自 virtual base class

同樣在這里也面臨ctor 中的問題（虛擬繼承時），最底層的class 必須調用共享的base class的copy operator，一種策略是，并不壓制上面的class 調用自己的copy operator ，也就是說允許了 共享部分的多重復制。另外一種方法是不要允許virtual base class 的copy 操作，甚至不要再任何virtual base class 中聲明數據~

··········析構語義學semantics of Destruction

如果class 沒有定義dtor 那么只有class 內帶的member object 或者自己的base class 有dtor 時候，編譯器才會合成一個來，否則dtor 被視為不需要了~~~（有virtual func 也不一定需要的）

dtor 調用順序是這樣的：

1 dtor  函數本身執行，

2 如果class 擁有member class object 而后者擁有dtor 那么他們會以相反的順序被調用

3 如果object 帶有vptr ，現在被重新設定，指向適當的base class vtble

4 如果任意直接的nonvirtual base class 有dtor ，他們會以聲明的相反順序調用

5 如果任意virtual base class 有destructor ，而當前討論的這個class 是最低端的most –derived class 那么他們會以原來的構造順序相反順序調用

一個object 的生命周期結束于dtor 開始執行時，由于每一個base class dtor 輪番調用，所以一個derived object 實際上變成了一個個完整的objec ；一如 PVertex->Vertex3d->Vertex->Point3d->Point

對象的蛻變會因為vptr 重新設定受到影響（dtor中，程序員代碼之前）,在程序中施行dtor的真正語義會在下一章具體表述~~

#include <time.h>
#include <iostream> 
using namespace std;  
class memberclass{
public: 
     memberclass(){cout<<"memberclass default ctor"<<endl;}
    memberclass(int x){cout<<"memberclass ctor with parameter"<<endl;}
    ~memberclass(){cout<<"memberclass dtor"<<endl;}
};
class Point{public: Point(){cout<<"point ctor"<<endl;test();}
~Point(){cout<<"point dtor"<<endl;test();}
virtual void test(){cout<<"point test"<<endl;}
};
class Point3d:virtual public Point{public: Point3d(){cout<<"Point3d ctor"<<endl;test();}
~Point3d(){cout<<"Point3d dtor"<<endl;test();}
virtual void test(){cout<<"Point3d test"<<endl;}};
class vertex:virtual public Point{public: vertex(){cout<<"vertex ctor"<<endl;test();}
~vertex(){cout<<"vertex dtor"<<endl;test();}
virtual void test(){cout<<"vertex test"<<endl;}
};
class vertex3d:public Point3d ,public vertex{public: 
memberclass inside;
vertex3d(){cout<<"vertex3d ctor"<<endl;test();}
~vertex3d(){cout<<"vertex3d dtor"<<endl;test();}
virtual void test(){cout<<"vertex3d test"<<endl;}
};
class pvertex:public vertex3d{public: 
memberclass inside;
pvertex():inside(3){cout<<"pvertex ctor"<<endl;test();}
~pvertex(){cout<<"pvertex dtor"<<endl;test();}
virtual void test(){cout<<"pvertex test"<<endl;}
};
int main(){ 
    pvertex* p = new pvertex;
    delete p;
    return 0;
}

輸出： guess it ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`

point ctor
point test
Point3d ctor
Point3d test
vertex ctor
vertex test
memberclass default ctor
vertex3d ctor
vertex3d test
memberclass ctor with parameter
pvertex ctor
pvertex test
pvertex dtor
pvertex test
memberclass dtor
vertex3d dtor
vertex3d test
memberclass dtor
vertex dtor
vertex test
Point3d dtor
Point3d test
point dtor
point test

---------------------------------------------------OVER--------------------------------------------------------