執行期語義學 RunTime Semantics
if( yy == xx.getValue() ) …
X xx; Y yy;
class Y{
public:
Y(); ~Y(); bool operator == (constY& )const;
};
class X{
public:
X(); ~X(); operator Y()const; //重載轉換類型操作符 必須成員不能有參數不能有返回值詳細在 http://www.shnenglu.com/zqsand/archive/2010/03/15/109748.html里面有介紹
X getValue();
};
看看上面的表達式怎么執行的~~~
首先等號運算符的參數確定 if(yy.operator==(xx.getValue()));
Y的== 需要一個Y型的參數，但是getvalue得到的是一個X型的，如果沒有X到Y的轉型方法，這個式子是錯的~ 而恰好X有個類型轉換符~
if(yy.operator == (xx.getValue().operator Y()))
增加的代碼都是編譯器默默為我們加上的~~~
注意在這個過程中，我們需要一個臨時的Xobject 儲存 getValue返回值 X temp1 = xx.getValue()
一個class Y object 儲存 operator Y()返回值 Y temp2 = temp1.operator Y();
一個 int 放置 等號返回值 int tmp3 = yy.operator == (temp2);
最后析構函數會實施在每一個臨時class object上.
所以，我們的代碼變成：
{
X temp1 = xx.getValue();Y temp2 = temp1.operator Y();int tmp3 = yy.operator == (temp2);
if(tmp3) dosth```
tmp2.Y::~Y();
tmp1.X::~X();
}
surprise~~-----------------------------------------------------------------------
6.1-對象的構造和析構
·一般來說，dtor會被放在每一個離開點（object 還存活）之前 ，所以，如果一個區段或者函數有多個離開點，那么每一個return 離開點都要插入一個dtor了。因此我們一般盡量放置object在使用它的程序區段附近，節省不必要的對象產生與摧毀操作。
·全局對象：全局對象如果有ctor或者dtor的話需要靜態的初始化操作和內存釋放操作。c++中全局對象放在data segment中，如果不明確指定值，內存內容為0.
但是ctor必須等到程序startup后才能實施。由于必須對一個放在datasegment 中的object初始化表達式evaluate ，所以object需要靜態初始化
一種策略（cfont 的 munch）
為每一個需要靜態初始化的檔案產生一個 _sti()函數，內帶必要的ctor調用操作或者inline expansions。 類似的產澀會給你一個std()函數調用dtor
一個_main()函數調用sti 一個 exit()函數調用_std()
然后cfont在我們的程序中安插對 _main _exit 的調用。 最后需要解決的是如何收集各個對象的sti和std。cfont使用了nm命令 ， 打印出符號表格(目標文件的符號表)，然后munch會搜索所有用sti或者std開頭的目標函數，把他們記錄到一個表格，當main和exit調用時候便利表格即可。
修改版本的方法是：system V中，coff格式的目標文件，檢驗可執行文件，找出有著_linknodes并且內帶一個指針指向 sti 和std函數的文件，把他們都串聯起來，接下來把鏈表頭結點設置為一個全局的_head object (定義在新的 patch runtime library)，這個library中有一種不同的_main _exit 他們會以head為起點，遍歷鏈表，調用sti和std。
實際上現在的ELF格式，有init 和.fini兩個section，完成靜態初始化和釋放操作。編譯器設定的startup函數會完成平臺特定的支持
virtual base class 的指針或者引用存取virtual base class subobject，是一種只有在執行期才能加以確定的操作。所以，編譯器需要支持class object 的靜態初始化，至少涵蓋object的指針和reference。
局部靜態對象
const Matrix& identity(){
static Matrix mat_identity;
return mat_identity;
}
mat_identity的ctor必須只執行一次，mat_identity的dtor必須只執行一次
編譯器只在identity被調用的時候才構造mat_identity，這樣避免如果不被調用也需要構造所有對象。同時編譯器引入條件式解析~也就是如果構造了則解析之
對象數組：
Points knots[10];
如果Points沒有定義ctor和dtor只要分配空間即可
如果有default ctor ，ctor必須實施于每個元素身上~這是由runtime library 完成的。 cfont中 我們使用vec_new()函數 MS和Sun提供兩個函數，一個用來處理 vbs的class 一個處理內帶base class 的class，后者為 vec_vnew() 函數原型基本如下
void* vec_new(void *array,size_t elem_size,int elem_count,void (*ctor)(void*),void(*dtor)(void*,char)))
array如果是0，數組由new分配與heap， vec_new(&knots,sizeof(Point),10,&Point::Point,0);
6.2 new 和 delete 運算符
int *pi = new int(5);
執行步驟：
int* pi = __new (sizeof(int));
*pi = 5;
int *pi;
if(pi = __new(sizeof(int)))
*pi=5;
delete pi;
if(pi!=0)
__delete (pi);
注意pi并不會自動清除為0！
CTOR
Point3d * origin=new Point3d;
if(origin = __new(sizeof(Point3d))){
try{
origin = Point3d::Point3d(origin);
}
calch(…){
__delete(origin);
throw;//上傳exception
}
}
DTOR
delete origin;
if(origin!=0){
Point3d::~Point3d(origin);
__delete(origin);
}
一種library對new的設計：~~
extern void* operator new(size_t size){
if(size==0)size=1;
void *last_alloc;
while(!(last_alloc=malloc(size))){
if(_new_handler) (*_new_handler)();
else return 0;
}
return last_alloc;
}
雖然new T[0];是合法的，但是語言要求每次對new的調用必須返回一個獨一無二的指針，解決該問題的傳統方法是傳回一個指針，指向默認為1byte的內存區塊。所以size被設為1.然后這種設計允許使用者提供一個屬于自己的_new_handler() 函數。
extern void operator delete (void *ptr) { if(ptr)free (char*)ptr;}
針對數組的new 語義：
int *p_array = new int[5];
這時候 vec_new()不會真正調用，因為，它的主要功能是把default ctor 實施于class object數組的每個元素身上。new運算符會被調用：
int *p_array = (int*) __new(5*sizeof(int));
如果數組的class object 有default ctor vec_new才會被調用。
Point3d *p_array = new Point3d[10];編譯成:
Point3d *p_array = vec_new(0,sizeof(Point3d),10,&point3d::Point3d,&Point3d::~Point3d);
個別數組構造如果exception發生，dtor被傳輸給vec_new ，已經構造的object需要dtor 實施。
delete 時候，開始需要程序員指定大小，后來編譯器開始不適用程序員指定的，而是只需要寫delete [] ptr 即可。
如何記錄數組大小呢：
一種方法在vecnew返回的內存塊配置一個額外的word，大小放在其中。
如果
class Point {public:virtual ~Point (){}};
class Point3d : public Point {public:virtual ~Point3d(){}};
如果Point *ptr = new Point3d[10];
當我們delete [] ptr;時候只有 Point::~Point被掉用````
在vc里敲了代碼驗證確實如此~~~
實施于數組上的dtor是根據交給vec_delete()函數的被刪除指針類型的dtor，也就是point的dtor，每一個元素大小也被一起傳了過去。
如何避免：
避免一個base class 指針指向一個derived class 的數組。如果真的要這么寫看代碼吧
class point{
public:
int p;
point(){cout<<"point ctor"<<endl;}
~point(){cout<<"point dtor"<<endl;}
};
class point3d:public point{
public:
int q;
point3d(){cout<<"point3d ctor"<<endl;}
~point3d(){cout<<"point3d dtor"<<endl;}
};
int main()
{
point *ptr = new point3d[3];
//delete [] ptr; 這樣寫是不行的
//要這樣寫
for(int i=0;i<3;i++){
point3d * p=&((point3d*)ptr)[i]; //恢復成point3d數組指針
delete p;
}
}
Placement Operator New
有一個重載過的new 運算符 需要兩個參數，類型為void*
Point2w *ptw = new(area) Point2w;
其中area指向內存一個區塊，用來放置產生出來的Point2w object.這個預先定義好的placement operator new 實現方法： 將獲得的指針arena 所指的地址傳回即可
void* operator new (size_t,void* p) {return p;}
事實上，他執行的另一半工作是：把point2w 的ctor 實施于 arena所指的地址上
Point2w *ptw = (Point2w *)arena; if(ptw!=0)ptw->Point2w::Point2w();
-------
p2w->~Point2w;
p2w = new(arena)Point2w;
如果我們用
delete p2w; p2w = new(arena) Point2w;
delete會釋放p2w指向的內存 由于下一指令還要用到p2w，我們應該調用dtor并保留存儲空間,以便再次使用.
還有一些關于placement opeator new 的設計問題··沒看明白 不記了··
6.3臨時對象 ：
c++對臨時對象并無硬性規定，由編譯器抉擇。
實際上 T c = a+ b; T operator + (const T& ,const T&);
a+b可以直接構建于c上
那么根本不產生臨時對象
但是，意義相當的 c=a+b;不能忽略臨時對象":
T temp; temp=operator+(a,b);c.operator =(tmp);tmp.T::~T();
注意c=a+b;中，直接傳遞c進入operator 中，也就是不要tmp的話：由于operator函數不為其外加參數調用dtor(期望一個新鮮的內存)，所以必須在其調用前調用dtor.然而轉換操作會變成c.T::~T();c.T::T(a+b);copy ctor dtor copy assignment operator 都可以自定義，所以我們用 析構和拷貝構造代替賦值一般而言是不安全的，所以需要臨時對象調用operator=
所以 T c=a+b;比 c=a+b;更有效率
臨時對象生命周期：
臨時對象被摧毀，應該是對完整表達式求職過程的最后一個步驟，該完整表達式造成臨時對象的產生
如果一個臨時對象綁定在一個reference上，對象將殘留，知道被初始化之reference生命結束，或者知道臨時對象的聲明范疇結束。