1、Member的各种调用方式
1.1 Nonstatic Member Functions
实际上编译器是将member function被内化为nonmember的形式，经过下面转化步骤：
1.给函数添加额外参数——this。
2.将对每一个nonstaitc data member的存取操作改为this指针来存取。
3.将member function 重写成一个外部函数。对函数名精选mangling 处理，使之成为独一无二的语汇。
class A{
public:
int x, y;
int func();
}
int A::func(){ return x+y; } //Nonstatic Member function
int A::func(A *const this) //1.添加额外参数this指针
{ return this->x + this->y;} //2.改为由this指针存取成员数据
extern int func_1AFv(A *const this) //3.对函数名进行“mangling”修饰
obj.func() ---> func_1AFv(&obj)1.2 Virtual Member Functions
将 ptr->f(); //f()为virtual member function 内部转化为 （*ptr->vptr[1]）(ptr); 其中：
vptr表示编译器产生的指针，指向virtual table。它被安插在每一个声明有（或继承自）一个或多个virtual functions 的class object 中。
1 是virtual table slot的索引值，关联到normalize()函数，此处表示第一个函数。
第二个ptr表示this指针
//明确的调用可以抑制虚拟机制
A::func()
// 通过该obj调用不支持多态
obj.func() ---> func_1AFv(&obj)
通过class object调用virtual function的操作会被编译器转换为一般的nonmember member function，不呈现多态。
1.3 Static Member Functions
- 参数没有this
- 不能被声明为 const volatile 或virtual。
- 不需要经过object 调用，可以使用class直接去调用
- 不能够直接存取其class中的非static member ，在static的作用域范围内，要想访问非static的数据成员，就得使用this指针
Static Member Function会被编译器转化为nonmember形式，实际上该类函数差不多等同于nonmember function。
一个static member function 会提出于class声明之外，并给予一个经过mangling的适当名称。如果取一个static member function 的地址，获得的是其在内存的位置也就是地址，而不是一个指向“class member function”的指针，如下：
&Point::count(); 会得到一个数值，类型是：unsigned int(*)(); 而不是：unsigned int(Point::*)();
static int A::func() //静态成员函数
//各种方式调用静态函数，均转换成通过类作用于直接调用
ptr->func()/obj.func()/A::func() --> A::func()
//函数mangling修饰
A::func() ---> func_1ASFv() //SFv表示静态成员函数，参数void
2、Virtual Member Funcitons
C++中，多态表示以“一个public base class 的指针（或reference)，寻址出一个derived class object”。
2.1 编译期间完成的事情
- 给每一个class object安插由编译器内部产生的vptr
- 给vtbl每一个virtual function一个固定的slot，在整个继承体系中保持与特定virtual funciton相联。这些active virtual function 包括：
这个class 所定义的函数实体（改写（overriding)一个可能存在的base class virtual function函数实体。
继承自base class 的函数实体（不被derived class改写）
一个pure_virtual_calle()
2.2 一个类继承函数virtual table的三种可能
1.继承base class 所声明的virtual functions的函数实体。正确地说，是该函数实体的地址会被拷贝到derived class的virtual table相对应的slot之中。
2.使用自己的函数实体。这表示它自己的函数实体地址必须放在对应的slot之中。
3.可以加入一个新的virtual function。这时候virtual table 的尺寸会增大一个slot放进这个函数实体地址。
2.3 单一继承
下面一个类Point的定义：
class Point {
public:
virtual ~Point(); //slot 1
virtual Point& mult (float) = //slot 2
float x() const {return _x;}
virtual float y() const {return ;} //slot 3
virtual float z() const {return ;} //slot 4
protected:
Point (float x = 0.0);
float _x;
}
class Point2d:public Point {
public:
~Point2d(); //slot 1
Point2d& mult (float) //函数覆盖 slot 2
float y() const {return _y;} //函数覆盖 slot 3
protected:
float _y;
}
class Point3d:public Point2d {
public:
~Point3d(); //slot 1
Point3d& mult (float) //函数覆盖 slot 2
float z() const {return _z;} //函数覆盖 slot 4
protected:
float _z;
}
//一般来说我们事先并不知道ptr所指对象真正类型
//所以不知道哪个mult实体会被调用，但mult()固定在slot 2中是确定的
ptr->mult()
//因此编译器如下转换
//执行期唯一需要做的就是确定哪一个slot 2的实体
(*ptr->vptr[])(ptr) Point2d继承自Point。Point3d继承自Point2d。那么内存模型如图:
编译时期设定virtual function的调用：
一般而言，我并不知道ptr 所指对象的真正类型。然而可以经由ptr 可以存取到该对象的virtual table。
虽然我不知道哪个Z()函数实体被调用，但知道每一个Z()函数地址都被放置slot 4的索引。
这样我们就可以将ptr->z();转化为：(*ptr->vptr[4])(ptr);
唯一一个在执行期才能知道的东西是：slot4所指的到底是哪一个z()函数实体
2.4 多重继承下的 Virtual Functions
多重继承下，通常派生类会有多个virtual table ，最左边基类的称之为：“主要表格”，第二或更过多基类的表格称为：“次要表格”（参考上图），派生类的主要表格和次要表格可以连在一起，比如Sun的编译器的策略就是这样的。
class Base1{ class Base2{
public: public:
Base1(); Base2();
virtual ~Base1(); virtual ~Base2();
virtual void SpeakClearly(); virtual void mumble();
virtual Base1* clone() const; virtual Base2* clone()const;
}; }; 这两个类我故意并列在一起，Base1和Base2的区别就是两个不同的虚函数void SpeakClearly()和void mumble();
class Derived: public Base1,public Base2{
public:
Derived();
virtual ~Derived();
virtual Derived* clone()const;
protected:
float data_derived;
}; 那么这几个类的virtual table的布局如下:
多重继承下：derived类会分别重写“主要表格”和“次要表格”
2.5 虚拟继承下的虚函数
3、函数的效能
nonmemeber、static member或nonstatic member函数都被转换为完全相同形式，所以三者效率完全相同。
4、指向Member Function的指针
4.1 nonstatic data member
取一个nonstatic data member的地址，得到的结果是该member在class 布局中的bytes位置，所以它需要绑定于某个class object的地址上，才能够被存取。
4.2 nonvirtual function指针
得到真实地址，但它需要绑定与某个class object上，才能通过它调用。
double (Point::*coord) = &Point::x; //nonvirtual function
//调用函数
(obj.*coord) ()
//被编译器转化
(coord)(&obj) //&obj为this指针
static member function函数地址为普通函数指针，因为没有this指针。
4.3 virtual function指针
virtual function地址在编译时期是未知的，但是与之相关的vtbl slot的索引值是固定的。所以取virtual function地址只能获得其索引值。
class Point{
public:
virtual ~Point(); //slot 1
virtual float z(); //slot 2
}
float (Point::*pmf) = Point::z; //= 2
Point *ptr = new Point2d;
ptr->*pmf;
//被编译器转化为
(*ptr->vptr[(int)pmf](ptr)); 4.4 多重继承下 member function指针
问题：如何区别Member Function指针指向地址还是virtual table索引？
方法：修改Member Function指针mptr结构体，mptr->index正负判别。
struct __mptr {
int delta;
int index; //virtual function时:vtbl索引 nonvirtual时为-1
union{
ptrtofunc faddr; //nonvirtual 时函数地址
int v_offse;
}
}5、Inline Funcitons
inline函数参数带有副作用，或者是以一个单一的表达式做多重调用，或是inline函数中有多个局部变量，都会产生临时对象，可能会产生大量的扩展码，是程序的大小膨胀，所以inline函数的使用必须要谨慎。
5.1 对于单一表达式的多重调用
对于如下incline函数：
inline Point operator+ (const Point& lhs, const Point& rhs)
{
Point new_pt;
new_pt.x(lhs.x() + rhs.x());//x()函数为成员变量_x的get，set函数
return new_pt;
}
由于该函数只是一个表达式，在cfront中，则其第二或者后继的调用操作不会被扩展，会变成：
new_pt.x = lhs._x + x__5PointFV(&rhs);
没有带来效率上的提升，需要重写为：
new_pt.x(lhs._x + rhs._x);
5.2 inline函数对于形式（Formal）参数的处理
有如下inline函数：
inline int min(int i, int j)
{
return i < j ? i : j;
}
如下三个调用：
inline int bar()
{
int minVal;
int val1 = ;
int val2 = ; minVal = min(val1, val2);//case 1
minVal = min(, );//case 2
minVal = min(foo(), bar() + );//case 3 return minVal;
}
对于case1，调用会直接展开：
minVal = val1 < val2 ? val1 : val2;
case2直接使用常量：
minVal = ;
对于case3，由于引发了参数的副作用，需要导入临时对象，以避免重复求值（注意下面逗号表达式的使用）：
int t1;
int t2; minVal = (t1 = foo()), (t2 = bar() + ), t1 < t2 ? t1: t2;
5.3 inline函数中引入了局部变量
改写上述min函数，引入一个局部变量：
inline int min(int i, int j)
{
int minVal = i < j ? i : j;
return minVal;
}
对于如下调用：
int minVal;
int val1 = ;
int val2 = ;
minVal = min(val1, val2);
为了维护局部变量，会被扩展为：
int minVal;
int val1 = ;
int val2 = ; int __min_lv_minVal;//将inline函数局部变量mangling
minVal = (__min_lv_minVal = val1 < val2 ? val1: val2), __min_lv_minVal;
再复杂一些的情况，例如局部变量加上有副作用的参数，会导致大量临时性对象的产生：
minVal = min(val1, val2) + min(foo(), bar() + );
会被扩展成为，注意逗号表达式，由左至右计算各个分式，以最右端的分式值作为最终值传回：
int __min_lv_minVal_00;
int __min_lv_minVal_01; int t1;
int t2; minVal = (__min_lv_minVal_00 = val1 < val2 ? val1 : val2, __min_lv_minVal_00) +
(__min_lv_minVal_01 = (t1 = foo(), t2 = bar() + , t1 < t2 ? t1 : t2), __min_lv_minVal_01);
会产生多个临时变量，所以inline函数的使用必须要谨慎。