文档章节

为什么不要在构造函数中调用虚函数

mskk
 mskk
发布于 2017/05/04 21:19
字数 2959
阅读 0
收藏 0

转自<http://www.cnblogs.com/carter2000/archive/2012/04/28/2474960.html>

 

先看一段在构造函数中直接调用虚函数的代码:

 

#include <iostream>

class Base
{
public:
    Base() { Foo(); }   ///< 打印 1

    virtual void Foo()
    {
        std::cout << 1 << std::endl;
    }
};

class Derive : public Base
{
public:
    Derive() : Base(), m_pData(new int(2)) {}
    ~Derive() { delete m_pData; }

    virtual void Foo()
    {
        std::cout << *m_pData << std::endl;
    }
private:
    int* m_pData;
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

 这里的结果将打印:1。

 

  这表明第6行执行的的是Base::Foo()而不是Derive::Foo(),也就是说:虚函数在构造函数中“不起作用”。为什么?

  当实例化一个派生类对象时,首先进行基类部分的构造,然后再进行派生类部分的构造。即创建Derive对象时,会先调用Base的构造函数,再调用Derive的构造函数。

  当在构造基类部分时,派生类还没被完全创建,从某种意义上讲此时它只是个基类对象。即当Base::Base()执行时Derive对象还没被完全创建,此时它被当成一个Base对象,而不是Derive对象,因此Foo绑定的是Base的Foo。

  C++之所以这样设计是为了减少错误和Bug的出现。假设在构造函数中虚函数仍然“生效”,即Base::Base()中的Foo();所调用 的是Derive::Foo()。当Base::Base()被调用时派生类中的数据m_pData还未被正确初始化,这时执行 Derive::Foo()将导致程序对一个未初始化的地址解引用,得到的结果是不可预料的,甚至是程序崩溃(访问非法内存)。

  总结来说:基类部分在派生类部分之前被构造,当基类构造函数执行时派生类中的数据成员还没被初始化。如果基类构造函数中的虚函数调用被解析成调用派生类的虚函数,而派生类的虚函数中又访问到未初始化的派生类数据,将导致程序出现一些未定义行为和bug。

  对于这一点,一般编译器会给予一定的支持。如果将基类中的Foo声明成纯虚函数时(看下面代码),编译器可能会:在编译时给出警告、链接时给出 符号未解析错误(unresolved external symbol)。如果能生成可执行文件,运行时一定出错。因为Base::Base()中的Foo总是调用Base::Foo,而此时Base::Foo 只声明没定义。大部分编译器在链接时就能识别出来。

 

#include <iostream>

class Base
{
public:
    Base() { Foo(); }   ///< 可能的结果:编译警告、链接出错、运行时错误

    virtual void Foo() = 0;
};

class Derive : public Base
{
public:
    Derive() : Base(), m_pData(new int(2)) {}
    ~Derive() { delete m_pData; }

    virtual void Foo()
    {
        std::cout << *m_pData << std::endl;
    }
private:
    int* m_pData;
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

 如果编译器都能够在编译或链接时识别出这种错误调用,那么我们犯错的机会将大大减少。只是有一些比较不直观的情况(看下面代码),编译器是无法判断出来的。这种情况下它可以生成可执行文件,但是当程序运行时会出错。

 

 

#include <iostream>

class Base
{
public:
    Base() { Subtle(); }   ///< 运行时错误(pure virtual function call)

    virtual void Foo() = 0;
    void Subtle() { Foo(); }
};

class Derive : public Base
{
public:
    Derive() : Base(), m_pData(new int(2)) {}
    ~Derive() { delete m_pData; }

    virtual void Foo()
    {
        std::cout << *m_pData << std::endl;
    }
private:
    int* m_pData;
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

 从编译器开发人员的角度上看,如何实现上述的“特性”呢?

 

  我的猜测是在虚函数表地址的绑定上做文章:在“当前类”(正在被构造的类)的构造函数被调用时,将“当前类”的虚函数表地址绑定到对象上。当基 类部分被构造时,“当前类”是基类,这里是Base,即当Base::Base()的函数体被调用时,Base的虚函数表地址会被绑定到对象上。而当 Derive::Derive()的函数体被调用时,Derive的虚函数表地址被绑定到对象上,因此最终对象上绑定的是Derive的虚函数表。

  这样编译器在处理的时候就会变得很自然。因为每个类在被构造时不用去关心是否有其他类从自己派生,而不需要关心自己是否从其他类派生,而只要按 照一个统一的流程,在自身的构造函数执行之前把自身的虚函数表地址绑定到当前对象上(一般是保存在对象内存空间中的前4个字节)。因为对象的构造是从最基 类部分(比如A<-B<-C,A是最基类,C是最派生类)开始构造,一层一层往外构造中间类(B),最后构造的是最派生类(C),所以最终对 象上绑定的就自然而然就是最派生类的虚函数表。

  也就是说对象的虚函数表在对象被构造的过程中是在不断变化的,构造基类部分(Base)时被绑定一次,构造派生类部分(Derive)时,又重 新绑定一次。基类构造函数中的虚函数调用,按正常的虚函数调用规则去调用函数,自然而然地就调用到了基类版本的虚函数,因为此时对象绑定的是基类的虚函数 表。

  下面要给出在WIN7下的Visual Studio2010写的一段程序,用以验证“对象的虚函数表在对象被构造的过程中是在不断变化的”这个观点。

  这个程序在类的构造函数里做了三件事:1.打印出this指针的地址;2.打印虚函数表的地址;3.直接通过虚函数表来调用虚函数。

  打印this指针,是为了表明创建Derive对象是,不管是执行Base::Base()还是执行Derive::Derive(),它们构造的是同一个对象,因此两次打印出来的this指针必定相等。

#include <iostream>

class Base
{
public:
    Base() { PrintBase(); }
    virtual ~Base() { PrintBase(); }

    void PrintBase()
    {
        std::cout << "Address of Base: " << this << std::endl;

        // 虚表的地址存在对象内存空间里的头4个字节
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Base Vtable: " << vt << std::endl;

        // 通过vt来调用Foo函数,以证明vt指向的确实是虚函数表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[1];   ///< 注意这里索引变成 1 了,因为析构函数定义在Foo之前
        (*pFoo)(this);

        std::cout << std::endl;
    }

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

class Derive : public Base
{
public:
    Derive() : Base() { PrintDerive(); }
    virtual ~Derive() { PrintDerive(); }

    void PrintDerive()
    {
        std::cout << "Address of Derive: " << this << std::endl;

        // 虚表的地址存在对象内存空间里的头4个字节
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Derive Vtable: " << vt << std::endl;

        // 通过vt来调用Foo函数,以证明vt指向的确实是虚函数表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[1];   ///< 注意这里索引变成 1 了,因为析构函数定义在Foo之前
        (*pFoo)(this);

        std::cout << std::endl;
    }

    virtual void Foo() { std::cout << "Derive" << std::endl; }
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

   打印虚函数表的地址,是为了表明在创建Derive对象的过程中,虚函数表的地址是有变化的,因此两次打印出来的虚函数表地址必定不相等。

  直接通过函数表来调用虚函数,只是为了表明前面所打印的确实是正确的虚函数表地址,因此Base::Base()的第19行将打印Base,而Derive::Derive()的第43行将打印Derive。

  注意:这段代码是编译器相关的,因为虚函数表的地址在对象中存储的位置不一定是前4个字节,这是由编译器的实现细节来决定的,因此这段代码在不同的编译器未必能正常工作,这里所使用的是Visual Studio2010。

#include <iostream>

class Base
{
public:
    Base() { PrintBase(); }

    void PrintBase()
    {
        std::cout << "Address of Base: " << this << std::endl;

        // 虚表的地址存在对象内存空间里的头4个字节
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Base Vtable: " << vt << std::endl;

        // 通过vt来调用Foo函数,以证明vt指向的确实是虚函数表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[0];
        (*pFoo)(this);

        std::cout << std::endl;
    }

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

class Derive : public Base
{
public:
    Derive() : Base() { PrintDerive(); }

    void PrintDerive()
    {
        std::cout << "Address of Derive: " << this << std::endl;

        // 虚表的地址存在对象内存空间里的头4个字节
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Derive Vtable: " << vt << std::endl;

        // 通过vt来调用Foo函数,以证明vt指向的确实是虚函数表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[0];
        (*pFoo)(this);

        std::cout << std::endl;
    }

    virtual void Foo() { std::cout << "Derive" << std::endl; }
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

 输出的结果跟预料的一样:

 

 

Address of Base: 002E7F98
Address of Base Vtable: 01387840
Call Foo by vt -> Base

Address of Derive: 002E7F98
Address of Derive Vtable: 01387834
Call Foo by vt -> Derive

 在析构函数中调用虚函数,和在构造函数中调用虚函数一样。

 

  析构函数的调用跟构造函数的调用顺序是相反的,它从最派生类的析构函数开始的。也就是说当基类的析构函数执行时,派生类的析构函数已经执行过, 派生类中的成员数据被认为已经无效。假设基类中虚函数调用能调用得到派生类的虚函数,那么派生类的虚函数将访问一些已经“无效”的数据,所带来的问题和访 问一些未初始化的数据一样。而同样,我们可以认为在析构的过程中,虚函数表也是在不断变化的。

  将上面的代码增加析构函数的调用,并稍微修改一下,就能验证这一点:

#include <iostream>

class Base
{
public:
    Base() { PrintBase(); }
    virtual ~Base() { PrintBase(); }

    void PrintBase()
    {
        std::cout << "Address of Base: " << this << std::endl;

        // 虚表的地址存在对象内存空间里的头4个字节
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Base Vtable: " << vt << std::endl;

        // 通过vt来调用Foo函数,以证明vt指向的确实是虚函数表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[1];   ///< 注意这里索引变成 1 了,因为析构函数定义在Foo之前
        (*pFoo)(this);

        std::cout << std::endl;
    }

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

class Derive : public Base
{
public:
    Derive() : Base() { PrintDerive(); }
    virtual ~Derive() { PrintDerive(); }

    void PrintDerive()
    {
        std::cout << "Address of Derive: " << this << std::endl;

        // 虚表的地址存在对象内存空间里的头4个字节
        int* vt = (int*)*((int*)this);
        std::cout << "Address of Derive Vtable: " << vt << std::endl;

        // 通过vt来调用Foo函数,以证明vt指向的确实是虚函数表
        std::cout << "Call Foo by vt -> ";
        void (*pFoo)(Base* const) = (void (*)(Base* const))vt[1];   ///< 注意这里索引变成 1 了,因为析构函数定义在Foo之前
        (*pFoo)(this);

        std::cout << std::endl;
    }

    virtual void Foo() { std::cout << "Derive" << std::endl; }
};

int main()
{
    Base* p = new Derive();
    delete p;
    return 0;
}

 

下面是打印结果,可以看到构造和析构是顺序相反的两个过程:

Address of Base: 001E7F98
Address of Base Vtable: 01297844
Call Foo by vt -> Base

Address of Derive: 001E7F98
Address of Derive Vtable: 01297834
Call Foo by vt -> Derive

Address of Derive: 001E7F98
Address of Derive Vtable: 01297834
Call Foo by vt -> Derive

Address of Base: 001E7F98
Address of Base Vtable: 01297844
Call Foo by vt -> Base

 最终结论:

    1. 不要在构造函数和析构函数中调用虚函数,因为这种情况下的虚函数调用不会调用到外层派生类的虚函数(参考:http://www.artima.com/cppsource/nevercall.htmlhttp://www.parashift.com/c%2B%2B-faq-lite/strange-inheritance.html#faq-23.5)。

    2. 对象的虚函数表地址在对象的构造和析构过程中会随着部分类的构造和析构而发生变化,这一点应该是编译器实现相关的。

注:以上的讨论是基于简单的单继承,对于多重继承或虚继承会有一些细节上的差别。

 

本文转载自:http://gaylord.iteye.com/blog/2117616

共有 人打赏支持
mskk
粉丝 3
博文 158
码字总数 3371
作品 0
昆山
程序员
私信 提问
C++ — 继承和多态的基础虚函数类

虚函数类 ————————————————————————————— 上一个博客继承中我们提到虚拟继承,现在我们来探究这种的虚函数,虚函数类的成员函数前面加virtual关键字,则这 个成...

Dawn_sf
2017/04/01
0
0
C++ virtual 析构函数

C++中虚析构函数的作用 我们知道,用C++开发的时候,用来做基类的类的析构函数一般都是虚函数。可是,为什么要这样做呢?下面用一个小例子来说明: 有下面的两个类: [cpp] view plain copy #...

geek_loser
2016/11/08
0
0
c++面试常用知识(sizeof计算类的大小,虚拟继承,重载,隐藏,覆盖)

一. sizeof计算结构体   注:本机机器字长为64位 1.最普通的类和普通的继承 #includeusing namespace std; class Parent{public: }; class Child : public Parent{public: }; int main(){ ......

余二五
2017/11/14
0
0
C++的虚伪

虚基类 当在多条继承路径上有一个公共的基类,在这些路径中的某几条汇合处,这个公共的基类就会产生多个实例(或多个副本),若只想保存这个基类的一个实例,可以将这个公共基类说明为 虚基类 虚基...

晨曦之光
2012/04/13
85
0
类的二三事

类 类的基本思想就是数据抽象和封装。数据抽象依赖于接口和实现。接口指类外成员对象可使用的函数接口。实现指类的成员函数和成员变量。封装实现了接口和实现的分离。 类本身就是一个作用域。...

sdoyuxuan
2017/04/07
0
0

没有更多内容

加载失败,请刷新页面

加载更多

设计模式“6”大原则!

面向对象设计原则 概述 对于面向对象软件系统的设计而言,在支持可维护性的同时,提高系统的可复用性是一个至关重要的问题,如何同时提高一个软件系统的可维护性和可复用性是面向对象设计需要...

Java干货分享
11分钟前
0
0
mybatis学习(1)

JDBC连接方式: 1.底层没有使用连接池,操作数据库需要频繁的创建和关闭连接,消耗资源。 2.写原生的JDBC代码在JAVA中,一旦需要修改SQL的话(比如表增加字段),JAVA需要整体重新编译,不利...

杨健-YJ
59分钟前
3
0
怎么组织文档

可以从以下几个方面考虑组织文档: ☐ 各种分支的界面截图和对应的类及文件 ☐ 框架或类图 ☐ 流程图 ☐ 时序图 ☐ 注意事项

-___-
今天
4
0
分布式之数据库和缓存双写一致性方案解析

引言 为什么写这篇文章? 首先,缓存由于其高并发和高性能的特性,已经在项目中被广泛使用。在读取缓存方面,大家没啥疑问,都是按照下图的流程来进行业务操作。 但是在更新缓存方面,对于更...

别打我会飞
今天
18
0
我的oracle11G,12c OCM之路

ocm认证感悟 ---------------------- 距离拿到ocm证书已经过了1年的时间,当初拿到证书的心情到现在还记得。其实在每个DBA心里都有一个成为强者的梦想,需要被认可,我也一样。我干过开发,做...

hnairdb
今天
6
1

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部