码迷,mamicode.com
首页 > 编程语言 > 详细

C++类成员空间分配和虚函数表

时间:2017-07-20 12:54:31      阅读:308      评论:0      收藏:0      [点我收藏+]

标签:int   test   div   c函数   efi   复习   overload   根据   同名   

最近在自学python,看到继承和类,就顺便复习了C++的类和继承等方面的知识。

先看Base基类

class Base {

private:

    virtual void display() { cout<<"Base display()"<<endl; }

    void say(){ cout<<"Base say()"<<endl; }

public:

    virtual void func(){cout << "Base func()" << endl; }
    void exec(){ display(); say(); }

    void f1(string a) { cout<<"Base f1(string)"<<endl; }

    void f1(int a) { cout<<"Base f1(int)"<<endl; }   //overload

};

Base类中定义私有的虚函数display, 普通成员函数say,公共的虚函数func, 普通的成员函数exec,重载了f1函数。

下面是DeriveA类,继承于Base类

class DeriveA:public Base{

public:

    void display() { cout<<"DeriveA display()"<<endl; }         //override

    void f1(int a,int b) { cout<<"DeriveA f1(int,int)"<<endl; }   //redefining

    void say() { cout<<"DeriveA say()"<<endl; }   //redefining

    virtual void func(){cout << "DeriveA func()" << endl; }

};

DeriveA类继承了Base类,重写(覆盖)了虚函数display和func,并且将display权限修改为public。重定义了f1函数和say函数,但是修改了f1的参数列表。

下面是基础的几个测试

     DeriveA a;

     Base *b=&a;

    b->func();
    a.func();
    b->f1("abc");
    b->f1(3);
    a.f1(3,5);    

 输出结果:

技术分享

func函数在Base类中为虚函数,DeriveA继承Base后,根据多态机制实现了动态调用。所谓多态机制就是用基类指针指向子类对象,基类指针调用虚函数func,会动态调用实际的子类对象的func函数。

由于display函数在Base类中为虚函数,所以不可以通过b->display()调用。由于DeriveA重新定义(redefining)了f1函数,f1函数参数类型修改了,所以只能使用a.f1(int,int)这种调用,而采用a.f1(string)或者

采用a.f1(int)这种调用都会出错,编译阶段就会出错。因为DeriveA类对f1重新定义了,基类的f1函数不可通过对象直接调用。同样的道理对于基类指针或对象,无论基类指针指向子类还是基类对象,调用f1只能

调用基类定义的两个f1(int), f1(string)两个函数,如果采用b->f1(3,5),编译器在编译阶段就会提出错误。想实现子类对象调用基类的函数可在函数体内加上作用于Base::函数名(参数,...)

DeriveA类修改f1函数,先调用基类的f1在调用自己的f1


class DeriveA:public Base{

public:

    void display() { cout<<"DeriveA display()"<<endl; }   //override

    void f1(int a,int b) { 
        Base::f1(2);
        Base::f1("test");
        cout<<"DeriveA f1(int,int)"<<endl; }   //redefining

    void say() { cout<<"DeriveA say()"<<endl; }   //redefining

    virtual void func(){
        
        cout << "DeriveA func()" << endl; }

}; 

打印输出

a.f1(3,5);

结果如下:

 技术分享

先调用了基类的两个f1函数,之后调用DeriveA的f1函数

下面调用如下函数

b->exec();

a.exec();

结果如下:

技术分享

为什么两个结果一样呢?

先看b->exec();由于b是Base类型变量,那么调用的Base类的exec函数,exec函数内部调用Base类的display()和say()函数。由于b为指向DeriveA类的基类指针,根据多态机制,调用Base类的display()函数时,会动态调用

DeriveA类的display()函数。调用Base类的say()函数时,由于say()函数不是虚函数,所以不触发多态机制。因此b->exec()函数的结果为调用DeriveA的display,调用Base的say函数。

由于DeriveA类继承于Base类,但是没有实现自己的exec()函数,即没有实现重定义,那么当执行a.exec()时,调用的时Base类的exec()函数,原理和上边一样,调用Base类中的display()函数和say()函数,由于display()函数为虚函数,

a为DeriveA类对象,调用基类的虚函数display(),根据多态机制,实际调用的是DeriveA类的display()函数。

执行下边代码

a.say()

结果如下:

技术分享

下面修改DeriveA类的内容,在DeriveA类内部实现自己的exec()函数

class DeriveA:public Base{

public:

    void exec(){ display(); say(); }

    void display() { cout<<"DeriveA display()"<<endl; }   //override

    void f1(int a,int b) { 
        cout<<"DeriveA f1(int,int)"<<endl; }   //redefining

    void say() { cout<<"DeriveA say()"<<endl; }   //redefining

    virtual void func(){
        
        cout << "DeriveA func()" << endl; }

};

 执行下边代码,

b->exec();

a.exec();

结果如下:

技术分享

因为DeriveA类重定义了exec函数,那么a.exec()函数调用的是DeriveA类的exec()函数,从而调用的都是DeriveA类的display()和say()函数。

继承类和基类成员函数调用规则总结:

DeriveA a;

Base *b=&a;

1 基类指针指向子类对象,该指针调用某个成员函数,先考虑该函数是否为虚函数,如果为虚函数,且子类有覆盖(重写),会触发多态机制,动态调用子类的重写函数:

如 b->func(), 输出为DeriveA func()

2 基类指针指向子类对象,该指针调用某个成员函数,先考虑该函数是否为虚函数,如果为虚函数,子类没有覆盖(没有重写),不会触发多态机制,调用基类的虚函数:

3  基类指针指向子类对象,该指针调用某个成员函数,如果该函数不为虚函数,无论该函数是否被子类重定义(redefined),只调用基类的该成员函数。如DeriveA类内部不实现

exec()函数,那么b->exec()调用的是Base类的exec()函数。

4  在第3条基础上,基类有成员函数exec(), 子类没有成员函数exec(),在基类的exec() 内部调用虚函数display(), 且子类覆盖了display()函数,那么根据多态机制,调用子类的display()。

如果display()虚函数没有被重写,则调用基类的display()函数,同第2条。如果exec()内部调用普通函数say(), 无论子类是否重定义say(),都会调用基类的say()函数,同3

5  Base类中实现exec()函数,而子类DeriveA类内部不实现exec()函数,DeriveA类对象调用exec()函数,实际调用的为Base类内部的exec()函数。如果exec()内部调用虚函数或者普通成员函数,

情况如同第4条。

6  Base类中实现exec()函数,而子类DeriveA类重定义exec()函数,那么DeriveA类对象调用的是DeriveA类的exec()函数。如果exec()函数内部调用DeriveA类的其他成员函数,那么调用的都是

DeriveA类的成员函数。

7 子类重定义了基类的成员函数,那么子类对象调用该成员函数,要根据子类重定义的形参列表。如a.f1(3,5);

 虚函数使用和定义规则:

(1)非类的成员函数不能定义为虚函数,类的成员函数中静态成员函数和构造函数也不能定义为虚函数,但可以将析构函数定义为虚函数。实际上,优秀的程序员常常把基类的析构函数定义为虚函数。

因为,将基类的析构函数定义为虚函数后,当利用delete删除一个指向派生类定义的对象指针时,系统会调用相应的类的析构函数。而不将析构函数定义为虚函数时,只调用基类的析构函数。

(2)只需要在声明函数的类体中使用关键字“virtual”将函数声明为虚函数,而定义函数时不需要使用关键字“virtual”。

(3)如果声明了某个成员函数为虚函数,则在该类中不能出现和这个成员函数同名并且返回值、参数个数、参数类型都相同的非虚函数。在以该类为基类的派生类中,也不能出现这种非虚的同名同返回值

同参数个数同参数类型函数。

 类的静态函数和构造函数不可以定义为虚函数:

1  静态函数的目的是通过类名+函数名访问类的static变量,或者通过对象调用staic函数实现对static成员变量的读写,要求内存中只有一份数据。而虚函数在子类中重写,并且通过多态机制实现动态调用,

在内存中需要保存不同的重写版本。

2  构造函数的作用是构造对象,而虚函数的调用是在对象已经构造完成,并且通过调用时动态绑定。动态绑定是因为每个类对象内部都有一个指针,指向虚函数表的首地址。而且虚函数,类的成员函数,

static成员函数都不是存储在类对象中,而是在内存中只保留一份。

  知其然、知其所以然(虚函数表原理):

虚函数存储在虚函数表中,每个类对象都包含一个指向该虚函数表首地址的指针。定义Baseclass类


class Baseclass { 

public: 
    Baseclass():a(1024){}
    virtual void f() { cout << "Base::f" << endl; } 
    virtual void g() { cout << "Base::g" << endl; } 
    virtual void h() { cout << "Base::h" << endl; } 
    int a;
}; 

从虚函数表中依次取出函数执行:

    Baseclass b; 

    cout <<"类对象大小" <<  sizeof(b) << endl;

    int * p = (int *)(&b) ;
    cout << "指向虚函数表的指针的地址"<< p << endl;
    cout <<"成员a地址"<< p+1 << endl;
    cout <<"成员a的数值" << *(p + 1) << endl;
    cout << "虚函数表首地址" <<(int *)(*p)  << endl;

    Func pFun =(Func) *(int *)(*p);
    pFun();
 
     pFun =(Func) *((int *)(*p) + 1);
    pFun();

     pFun =(Func) *((int *)(*p) + 2);
    pFun();
    

 

输出结果如下:

技术分享

可见类对象大小为8字节,4字节正好是指向虚函数表指针的大小。剩余4字节为成员变量a的大小。画个图示意虚函数表结构:

 技术分享

p指向的就是类对象的首地址,同时也是虚函数表指针(指向虚函数表的指针)的地址,*p指向虚函数表,

由于指针是4字节,(int *)(*p)虚函数表首地址,也是第一个函数指针的地址。

Derive类继承于Base类,但是没有覆盖(重写)Base类的虚函数,Derive d; 的虚函数表如下:

 

 技术分享

Derive类继承于Base类,并且覆盖(重写)Base类的虚函数,Derive d; 的虚函数表如下:

技术分享

可以看到d的虚函数表中第一个单元为Derive::f(),覆盖了原有的Base::f()。

Derive d;

Base * p = &d;

p指向d的首地址,其实就是d的虚函数表指针的地址,p->f()实际会调用虚函数表中的Derive::f(),从而实现多态。

多重继承结构如下:

 技术分享

虚函数表原理后可以篡改部分程序功能,其实很多外挂就是钩子函数回调注入的。

class Baseclass { 

public: 
    Baseclass():a(1024){}
private:
    virtual void f() { cout << "Base::f" << endl; } 

    virtual void g() { cout << "Base::g" << endl; } 

    virtual void h() { cout << "Base::h" << endl; } 

    int a;
}; 

class Deriveclass:public Baseclass{
public:
    Deriveclass():Baseclass(){}

};

由于Baseclass内部的虚函数是私有的,所以Deriveclass类变量是不能直接访问这些函数的。但是可以通过虚函数寻址,并且通过回调函数方式调用。

Deriveclass d;
    Func pFunc = (Func)*((int *)(*(int *)(&d)));
    pFunc();

结果如下:

技术分享

 

 C++类对象的大小为多大?

 

一个类中,虚函数、成员函数(包括静态与非静态)和静态数据成员都是不占用类对象的存储空间的。

对象大小=   vptr(可能不止一个)   +   所有非静态数据成员大小   +   Aligin字节大小(依赖于不同的编译器对齐和补齐)

 

定义几个类,然后输出他们大小。

class   A    
{    
};    

class   B    
{    
    char   ch;    
    void   func()    
    {    
    }    
};    

class   C    
{    
    char   ch1;    //占用1字节 
    char   ch2;   //占用1字节 
    virtual   void   func()    
    {    
    }    
};    

class   D    
{    
    int   in;    
    virtual   void   func()    
    {    
    }    
};    

class E
{
    char m;
    virtual void func()
    {
    
    }
};

 

 

 输出大小:

    A   a;  
    B   b; 
    C   c;  
    D   d; 
    E    e;

      cout<<"a对象大小: "<< sizeof(a)<<endl;
      cout<<"b对象大小: "<< sizeof(b)<<endl;
      cout<<"c对象大小: " <<sizeof(c)<<endl;
      cout<<"d对象大小: "<< sizeof(d)<<endl;
      cout <<"e对象大小: " <<sizeof(e) <<endl;


 

 结果如下:

技术分享

 类和结构体对象对齐和补齐原则?

 对齐:类(结构体)对象每个成员分配内存的起始地址为其所占空间的整数倍。

补齐:类(结构体)对象所占用的总大小为其内部最大成员所占空间的整数倍。

 

 空类定义的对象a  大小为1因为每个对象是独一无二的,编译器为了标识不同对象,要分配一字节的大小作为标识码。

对象b 大小为1是因为成员函数在内存中只存储一份,不会存储在对象中。

对象c大小为8, 是因为前四个字节存储虚函数表的指针,第5个字节存储成员变量ch1,第6个字节存储成员变量ch2,这样c的大小为6,根据补齐原则,需要补充2字节,使对象大小为8,8是最大字节4的整数倍。

对象d大小为8,不需要补齐和对齐。

对象e大小为8,前四个字节存储虚函数表指针,第5个字节存储成员m,需要补齐三个字节,总共八个字节,为4字节的倍数。

 看看下边这几个类

class F{ 
    static int num; 
}; 

class G{ 

    virtual void print(){} 
    virtual void  print1(){} 
}; 

class H{ 

    void print(){} 
    static void print1(){} 
}; 

 

 打印并输出大小:

    F f;
    cout<<"f 对象大小: "<< sizeof(f)<<endl;

    G g;
    cout<<"g 对象大小: "<< sizeof(g)<<endl;

    H h;
    cout<<"h 对象大小: "<< sizeof(h)<<endl;

 

 结果:

技术分享

静态成员变量,虚函数和static成员函数都不会占用对象的空间,f大小为1,是因为要开辟一个字节保存对象标识信息。

g大小为4是开辟四字节给虚函数表指针。h大小为1字节也是开辟一个字节保存对象标识信息

  什么要采取对齐和补齐分配策略?

这个要从计算机CPU存取指令说起,

 

 技术分享

 

 每个字节单元为8bit,从地址0到地址3总共四个字节,为32bit。

 class  A{

    char  m;

    char  b;

};

A a;  对于a 将a.m分配在地址0开始的一个字节中,将a.b分配在地址1开始的额一个字节中。这样a的大小为2,cpu取数据可以执行一条指令就完成了。

class B{

  int m;

  char n;

};

B b; 对于b将b.m分配在地址为0开始的四个字节(0~3),对于b.n分配在开始地址为4的一字节空间。如果再定一个B b2;,不采取补齐策略,b2.m将被分起始地址为5的

4字节空间(5~8),b2.n就被分在了起始地址为9的一字节空间。cpu取数据需要分3次,先取出0~3地址空间的数据(b.m),再取出地址4~7数据(b.n和b2.m的前三个字节)

最后取出地址为8~11的数据(b2.m的最后一个字节以及b2.n)。取出数据后还要拆分和组合,极大地降低了效率。所以需要采取补齐策略。补齐策略数据分配如下:

地址0~3存储b.m, 地址4~7存储b.n,由于b.n只占用1个字节,地址5~7不存储数据,用于补齐。

地址8~11存储b2.m,地址12~15存储b2.n,13~15同样不存储数据用于补齐。

这样cpu读取四次可以将数据读取出来,进行简单的组合不需要切割数据就可以完成快速处理。

class C{

   char n;

   int  m;

}

 C c; c.n存储周期0开始的一个字节中,如果不采取对齐策略,那么c.m会存储在1~4字节中,这样cpu需要读去两次,并且需要进行切割(0~4地址中数据包含c.n和c.m的前三个字节),

以及组合地址4开始的一个字节(存储c.m的最后一个字节)。如果采取对齐策略,那么地址0~3存储c.n,地址4~7存储c.m,cpu同样读取两次,但是仅需要组合就可以去除对象的所有数据。

这就是为什么存储数据需要采取对齐和补齐的策略。

 到此为止C++虚函数和类成员的存储知识复习完,谢谢关注我的公众号:

技术分享

 

 

 

 

 

 

 

 

 

 

 

 

 

C++类成员空间分配和虚函数表

标签:int   test   div   c函数   efi   复习   overload   根据   同名   

原文地址:http://www.cnblogs.com/secondtonone1/p/7205108.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!