【C++对象模型】第四章 Function 语意学

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) = 0   //slot 2
    float x() const {return _x;}
    virtual float y() const {return 0;}   //slot 3
    virtual float z() const {return 0;}   //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[2])(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 = 1024;  
        int val2 = 2048;  
      
        minVal = min(val1, val2);//case 1  
        minVal = min(1024, 2048);//case 2  
        minVal = min(foo(), bar() + 1);//case 3  
          
        return minVal;  
    }

　　对于case1，调用会直接展开：

    minVal = val1 < val2 ? val1 : val2;

　　case2直接使用常量：

    minVal = 1024;

　　对于case3，由于引发了参数的副作用，需要导入临时对象，以避免重复求值（注意下面逗号表达式的使用）：

    int t1;  
    int t2;  
      
    minVal = (t1 = foo()), (t2 = bar() + 1), 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 = 1024;  
    int val2 = 2048;  
    minVal = min(val1, val2); 

　　为了维护局部变量，会被扩展为：

    int minVal;  
    int val1 = 1024;  
    int val2 = 2048;  
      
    int __min_lv_minVal;//将inline函数局部变量mangling  
    minVal = (__min_lv_minVal = val1 < val2 ? val1: val2), __min_lv_minVal;  

　　再复杂一些的情况，例如局部变量加上有副作用的参数，会导致大量临时性对象的产生：

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

　　会被扩展成为，注意逗号表达式，由左至右计算各个分式，以最右端的分式值作为最终值传回：

    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() + 1, t1 < t2 ? t1 : t2), __min_lv_minVal_01); 

　　会产生多个临时变量，所以inline函数的使用必须要谨慎。