1. 非虛成員函式指標（非靜態）。

取一個非靜態成員函式的地址，如果該函式是非虛擬函式，則得到的是它在記憶體中的真正地址，但是該地址並不完全，需要繫結與具體的類例項（物件）之上，藉助物件的地址（this指標）才可以被呼叫，例如：一個成員函式指標

1. double (Point::* pmf)();  

1. double (Point::*coord)() = &Point::getX;//或者這樣初始化它：coord = &Point::getX;

1. (orgin.*coord)();//或者這樣(ptr->*coord)();

1. (coord)(&origin);
   //或者(coord)(ptr);

2. 指向虛成員函式的指標。

當一個函式指標指向一個虛成員函式時，例如：

1. float (Point::*pmvf)() = &Point::z;//z為虛擬函式
2. Point *ptr = new Point3d;//Point3d為Point的子類

1. (ptr->*pmvf)();//效果等同於ptr->z();

1. class Point {  
2. public:  
3.     virtual ~ Point();  
4.     float x();  
5.     float y();  
6.     virtualfloat z();  
7. };  

1. (*ptr->vptr[(int)pvmf])(ptr);//呼叫Point3d::z()

由於多重繼承（包括多重虛擬繼承）涉及到，子類中可能存在多個虛表，this指標的可能需要調整偏移，書中舉例了cfront的實現方法，引入一個結構體，在需要的時候儲存上述內容，結構體如下：

1. struct __mptr {  
2.     int delta;//虛基類或者多重繼承下的第二個以及之後基類的this指標偏移
3.     int index;//虛擬函式索引，非虛擬函式此值為-1
4.     union {  
5.         ptrtofunc faddr;//非虛擬函式地址
6.         int v_offset;//虛基類或者多重繼承下的第二個以及之後基類的虛表位置
7.     };  
8. };  

1. (ptr->*pmvf)();  

1. (pmvf.index < 0) ?  
2. (*pmvf.faddr)(ptr)//非虛擬函式
3. : (*ptr->vptr[pmvf.index])(ptr);//虛擬函式

1. 對於單一表達式的多重呼叫：

對如下incline函式：

1. inline Point operator+ (const Point& lhs, const Point& rhs)  
2. {  
3.     Point new_pt;  
4.     new_pt.x(lhs.x() + rhs.x());//x()函式為成員變數_x的get，set函式
5.     return new_pt;  
6. }  

1. new_pt.x = lhs._x + x__5PointFV(&rhs);  

1. new_pt.x(lhs._x + rhs._x);  

有如下inline函式：

1. inlineint min(int i, int j)  
2. {  
3.     return i < j ? i : j;  
4. }  

1. inlineint bar()  
2. {  
3.     int minVal;  
4.     int val1 = 1024;  
5.     int val2 = 2048;  
6.     minVal = min(val1, val2);//case 1
7.     minVal = min(1024, 2048);//case 2
8.     minVal = min(foo(), bar() + 1);//case 3
9.     return minVal;  
10. }  

1. minVal = val1 < val2 ? val1 : val2;  

1. minVal = 1024;  

1. int t1;  
2. int t2;  
3. minVal = (t1 = foo()), (t2 = bar() + 1), t1 < t2 ? t1: t2;  

1. inlineint min(int i, int j)  
2. {  
3.     int minVal = i < j ? i : j;  
4.     return minVal;  
5. }  

1. int minVal;  
2. int val1 = 1024;  
3. int val2 = 2048;  
4. minVal = min(val1, val2);  

1. int minVal;  
2. int val1 = 1024;  
3. int val2 = 2048;  
4. int __min_lv_minVal;//將inline函式區域性變數mangling
5. minVal = (__min_lv_minVal = val1 < val2 ? val1: val2), __min_lv_minVal;  

再複雜一些的情況，例如區域性變數加上有副作用的引數，會導致大量臨時性物件的產生：

1. minVal = min(val1, val2) + min(foo(), bar() + 1);  

會被擴充套件成為，注意逗號表示式，由左至右計算各個分式，以最右端的分式值作為最終值傳回：

1. int __min_lv_minVal_00;  
2. int __min_lv_minVal_01;  
3. int t1;  
4. int t2;  
5. minVal = (__min_lv_minVal_00 = val1 < val2 ? val1 : val2, __min_lv_minVal_00) +  
6. (__min_lv_minVal_01 = (t1 = foo(), t2 = bar() + 1, t1 < t2 ? t1 : t2), __min_lv_minVal_01);