構(gòu)造，析構(gòu)，拷貝語義學(xué) semantics of construction destruction and copy
純虛擬函數(shù)的存在(Presence of a Pure Virtual Function)
純虛擬函數(shù)是可以定義并調(diào)用的，只不過只能被靜態(tài)調(diào)用，不能經(jīng)由虛擬機制。（經(jīng)過試驗vs2008是不可以的）
而pure virtual destructor ：class 設(shè)計者一定要定義它。因為每一個derived class的destructor會被編譯器加以擴展，以靜態(tài)方式調(diào)用其每一個virtual base class 以及上層base class 的destructor ，因此缺乏任何一個base class destructor 的定義就會導(dǎo)致連接失敗
基類的析構(gòu)函數(shù)應(yīng)該設(shè)置為虛擬的，不一定是純虛的 ，除非在希望將一個類變成抽象類（不能實例化的類），而這個類又沒有合適的函數(shù)可以被純虛化的時候，可以使用純虛的析構(gòu)函數(shù)來達到目的。
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的析構(gòu)函數(shù)沒有設(shè)置為虛擬的，那么delete a 的時候只有調(diào)用了A的析構(gòu)函數(shù)，真正的B并沒有調(diào)用。而如果虛擬的話，那么a調(diào)用析構(gòu)函數(shù)會調(diào)用B的析構(gòu)函數(shù)，而B的析構(gòu)函數(shù)會調(diào)用A的析構(gòu)函數(shù)。
虛擬函數(shù)的取舍：如果一個函數(shù)被設(shè)計為虛擬函數(shù)，但是他函數(shù)定義并不與類型相關(guān)，也就是說繼承類改寫他的幾率很低，那么這是個糟糕的事情。如果不是虛擬而且能內(nèi)聯(lián)，這是個很大的損失
---------
沒有繼承下的對象構(gòu)造
Plain OI’s data 形式
例如 struct {float x,y,z;}
理論上編譯器會生成沒有用的trival ctor dtor copytor copy operator ，然而事實上什么也沒有發(fā)生。
全局對象，c中會被放在bss段，而c++中的全局對象會被視為完全定義，被當(dāng)做初始化過的數(shù)據(jù)來對待。
抽象數(shù)據(jù)類型：
class Point {public: Point (float x=0):_x(x){}; private: _x;}
經(jīng)過封裝的Point class 大小沒有改變 由于默認的member wise 賦值語義已經(jīng)足夠，我們無需提供copy constructor 和copy operator。對于global 實體，Point::Point(0) 會自動調(diào)用 (程序開始時候startup())
如果要對class所有成員都設(shè)定常量初值，那么給予一個explicit initial list 會比較高效。
例如 void mumble(){
Point A1={1};
Point A2; A2._x=1;
}
A2的初始化會比A1慢，因為，當(dāng)activation record（活動記錄 是不是棧中的pc 指針），上述的list中常量就可以放進A1的內(nèi)存中了
explicit initialzation list （A1的那種）缺點：public 才可以；只能指定常量；
Point *heap = new Point;
翻譯為：
Point *heap = __new(sizeof(Point));
if(heap)heap->Point::Point();
`````
為繼承準(zhǔn)備：
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 都是數(shù)值，因此默認語義下情況良好。virtual destructor 也沒有引入啊，同樣道理，行為良好即可
virtual func 的引入給我們的 Point class 帶來了膨脹作用:
定義的構(gòu)造函數(shù)被附加了一些代碼，用來初始化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 錯誤
···············
繼承體系下的對象構(gòu)造：
如果定義 T object 會發(fā)生什么
1.member initialization list 中的data number 初始化操作會放到ctor 中并以聲明順序排列
2.如果一個member沒有出現(xiàn)在 list 中但他有default constructor ，他必須被調(diào)用
3.在那之前，如果class object有vptr 那么他必須設(shè)定初值指向正確vtable
4.在那之前，任何上一層base class ctor 必須被調(diào)用，以base class 聲明順序，
如果base class 列于 初始化列表中，參數(shù)被傳遞
如果base class 不再列表，有默認ctor 調(diào)用
如果base class 是多重繼承下 第二或者后繼的base class this 指針調(diào)整
5.在那之前virtual base class ctor 必須被調(diào)用 從左至右，由深到淺
如果base class 列于 初始化列表中，參數(shù)被傳遞如果base class 不再列表，有默認ctor 調(diào)用
base class subobject 的offset 必須在執(zhí)行期可以被存取
··························
虛擬繼承
虛擬繼承比較具有特殊性，因為他具有共享性。在這樣一個繼承體系中
Point 3d 和Vertex 虛擬繼承自Point ，此時如果按照普通的ctor 規(guī)則。Vertex 的ctor 必須調(diào)用Point 的ctor ，然而 當(dāng) Point3d 和 Vertex 同為Vertex3d的subobject時，他們的調(diào)用一定不能發(fā)生(this指針的調(diào)整問題) ,而只能有 Vertex3d才可以調(diào)用，同樣，PVertex構(gòu)造時候只能由他自己調(diào)用，也就是說只有底層的class 完成構(gòu)建共享的subobject構(gòu)造。我們可以用一個most _derived參數(shù)傳給各個構(gòu)造函數(shù)以指示其是否調(diào)用共享部分的ctor。
事實上我們發(fā)現(xiàn)，只有當(dāng)object 是完整object時才會調(diào)用共享部分的ctor ，而部分subobject不會調(diào)用，從而得到新的策略，提供兩種構(gòu)造函數(shù)一種供完整的object 一種供subobject調(diào)用
~~~~vptr 初始化語義學(xué)~~~
c++語言告訴我們：在Point3d ctor 調(diào)用size函數(shù)，必須決議為 point3d 的size 而不是 pvertex的size，可以理解為在ctor和dtor 中虛函數(shù)決議為自己的函數(shù)，他不虛啦~~~~~(實際上是因為他沒有變身完全)
ctor 調(diào)用順序是從根源到末端，從內(nèi)而外。當(dāng)base class ctor 執(zhí)行時候 derived實體還沒有構(gòu)造出來，在pvertex 構(gòu)造完整之前，pvertex并不是一個完整的對象，因此只有Point3d subobject構(gòu)造完畢，這意味著每一個pvertex base class ctor 調(diào)用時候，編譯器必須保證有適當(dāng)?shù)?size 函數(shù)實體來調(diào)用 how，so 決議為自己的size
另一種方法是控制vptr，
在base class ctor 調(diào)用之后，但是在程序員提供代碼或者initial list 之前，我們設(shè)定vptr ，也就是說我們保證vptr指向剛剛構(gòu)造完畢的base clas subobject 對應(yīng)的vtable ，保證了它能夠調(diào)用正確的virtual func；
所以對象構(gòu)造是這樣的過程：
一個 PVertex對象會先形成一個 Point對象- >Point3d->Vertex->Vertex3d->PVertex
ctor執(zhí)行算法:
1.derived class ctor 中所有 virtual base class 和上一級base class 調(diào)用
2. 上述完成vptr 初始化，指向相應(yīng)的vtable
3.如果有member initial list 的haunted，將在ctor 展開，這些必須在vptr 設(shè)定后進行，防止有virtual func 調(diào)用
4.最后執(zhí)行程序員寫的代碼
vptr 需要被設(shè)定的兩種情況：
1.對象完整定義后
2.當(dāng)一個subobject ctor 調(diào)用了一個虛擬函數(shù)時候（上面說的很明白嘍）
當(dāng)聲明一個PVertex對象時候，由于我們對base class ctor 的定義，其vptr 不需要每一個base class ctor 中設(shè)定，因此我們可以把ctor 分解成兩部分，一種完整的object 實體，一種subobject實體，subobject實體中vptr 設(shè)定可以是省略
如果在class ctor initiallist 調(diào)用該class 虛擬函數(shù)安全么？ 理論上安全，但是如果依賴未初始化member 不安全
``````````````````
對象復(fù)制語義學(xué) object copy semantics
我們有三種選擇：
1 什么都不做，按默認行為實施
2 提供一個explicit copy assignment operator
3 明確拒絕把一個class object 指定給一個class object （聲明一個private 的copy assignment operator）
下列情況下，class 不表現(xiàn)出bitwise 的復(fù)制語義，也就是說默認的copy operator 是不夠的：（和之前介紹的一樣）
1.class 有一個member object 而他有copy operator
2.class的base class 有一個copy operator
3.當(dāng)class 聲明virtual func時 （由于要設(shè)定vptr when derived to base）
4.class 繼承自 virtual base class
同樣在這里也面臨ctor 中的問題（虛擬繼承時），最底層的class 必須調(diào)用共享的base class的copy operator，一種策略是，并不壓制上面的class 調(diào)用自己的copy operator ，也就是說允許了 共享部分的多重復(fù)制。另外一種方法是不要允許virtual base class 的copy 操作，甚至不要再任何virtual base class 中聲明數(shù)據(jù)~
··········析構(gòu)語義學(xué)semantics of Destruction
如果class 沒有定義dtor 那么只有class 內(nèi)帶的member object 或者自己的base class 有dtor 時候，編譯器才會合成一個來，否則dtor 被視為不需要了~~~（有virtual func 也不一定需要的）
dtor 調(diào)用順序是這樣的：
1 dtor 函數(shù)本身執(zhí)行，
2 如果class 擁有member class object 而后者擁有dtor 那么他們會以相反的順序被調(diào)用
3 如果object 帶有vptr ，現(xiàn)在被重新設(shè)定，指向適當(dāng)?shù)腷ase class vtble
4 如果任意直接的nonvirtual base class 有dtor ，他們會以聲明的相反順序調(diào)用
5 如果任意virtual base class 有destructor ，而當(dāng)前討論的這個class 是最低端的most –derived class 那么他們會以原來的構(gòu)造順序相反順序調(diào)用
一個object 的生命周期結(jié)束于dtor 開始執(zhí)行時，由于每一個base class dtor 輪番調(diào)用，所以一個derived object 實際上變成了一個個完整的objec ；一如 PVertex->Vertex3d->Vertex->Point3d->Point
對象的蛻變會因為vptr 重新設(shè)定受到影響（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--------------------------------------------------------