由static_cast和dynamic_cast到C++对象占用内存的分析

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/keheinash/article/details/52049456

static_cast和dynamic_cast是C++的类型转换操作符。编译器隐式执行的任何类型转换都可以由static_cast显式完成,即父类和子类之间也可以利用static_cast进行转换。而dynamic_cast只能用于类之间的转换。那么dynamic_cast的存在还有什么意义呢?因为dynamic_cast提供了一个重要的特性:运行时类型检查来保证转换的安全性。

用static_cast转换存在的危险

我们知道,一个基类指针不需要进行明确的转换操作,就可以指向基类对象或者派生类对象。比如:

class Base{
    //…
};
class Derived{
    //…
};
int main{
    Base *p = new Base();//OK
    Base *p = new Derived();//OK
}

上面的两种定义都是正确的,那么如果想反过来,让一个子类指针指向父类对象呢?如下代码:

class Base{
    //…
};
class Derived{
    //…
};
int main{
    Derived *p = new Base();//error
    Derived *p = static_cast<Derived*>(new Base());//OK
}

如果直接把Base类型的指针转换为Derived类型的指针,那么编译时会报错。如果在转换时加上static操作符则可以顺利通过编译。但是这种做法是十分危险的,在运行期时可能会出现一些难以预测和查找的错误。如下面代码:

class Base{
    public:
        Base():m_b(4){};
        int m_b;
void m_funcB(){cout << "base" << endl;};
};
class Derived:public Base{
    public:
        Derived():m_d(3){};
        int m_d;
        void m_funcD(){cout << "derived" << endl;};
};
int main(){
    Derived* p = static_cast<Derived*>(new Base());
    cout << p->m_d << endl;
    p->m_funcD();
}

虽然p是Derived类型的指针,但是实际却指向了Base对象,而Base对象不存在m_d这个数据成员,因此输出的结果不可预测(在我的机子上一直输出0)。正是这种不可预测才导致难以追踪的错误,试想,如果执行这段代码会崩溃,那么还是比较还排查的,但是现在并不一定崩溃,只是执行的结果和我们的预测不一致,可能将导致连环的逻辑错误,这就像给自己挖了一个坑或者定时炸弹。
但是很奇怪的一点是,执行p->m_funcD()这一句后,居然可以打印出”derived”。这是怎么回事?m_funcD明明是类Derived的函数,而且类Base里并不存在这个函数,这个我们留在后面说明。

利用dynamic_cast保证转换的安全

原则上,我们不应该让子类指针指向父类的对象。但是如果写下了上面这样的代码,我们希望可以有一种检查机制可以帮助我们发现这个问题,这样就可以避免对转换后的指针进行操作,造成不可预料的后果。
C++是支持运行期类型识别的(RTTI),这种机制除了帮助我们实现多态,还能在类型转换时进行安全检查。回到上面的代码,我们稍作修改:

class Base{
    public:
        Base():m_b(4){};
        int m_b;
        virtual void m_funcB(){cout << "base" << endl;};
};

class Derived:public Base{
    public:
        Derived():m_d(3){};
        int m_d;
        void m_funcD(){cout << "derived" << endl;};
};
int main(){
    Derived* p = dynamic_cast<Derived*>(new Base());
    cout << p->m_d << endl;
    p->m_funcD();
}

运行结果会是什么?程序崩溃了。原因就是我们执行了p->m_d,而p这个时候是一个空指针。原因在于利用dynamic_cast进行类型转换时会进行安全检查,在这里我们将一个父类指针转换为子类指针,这被认为是一个无效操作,因此返回NULL,因此p成了空指针。所以当我们利用dynamic_cast进行了转换后,只要对得到的指针进行检查,就可以知道转换是否成功。static_cast则没有提供这种检查,这就是dynamic_cast比static_cast安全的原因。
现在稍微离开一下正题,如果把打印m_d这句注释掉,执行p->m_funcD()这一句后,发现还是能够打印出”derived”。等我们总结dynamic_cast和static_cast的区别后就对这个现象进行讨论。

dynamic_cast和static_cast的区别:

dynamic_cast可以实现运行期类型安全检查,是一种更加安全的方法,但是仅仅对多态类型有效,而且只能用于指针或者引用类型的转换上。static_cast则可应用与任何类型,而且不需要类型实现了多态。static_cast的应用更加广泛,但是dynamic_cast更加强大和安全。

对象占用内存分析:

下面看一下我们两次提到的现象:为什么通过一个实际指向了基类对象的子类指针调用子类的方法,既然没有出现错误并且可以顺利调用?
一个类无非就是包含两种成员:数据和方法。那么当我们实例化出一个对象的时候,这个对象包含了哪些东西,实际占用的内存大小是多少?写一段代码试一试:

class Base{
    public:
        Base():m_b(4){};
        int m_b;
        virtual void m_funcB(){cout << "base" << endl;};
};
class Derived:public Base{
    public:
        Derived():m_d(3){};
        int m_d;
        void m_funcD(){cout << "derived" << endl;};
};
int main(){
    cout << sizeof(Base) << endl;   
    cout << sizeof(Derived) << endl;
}

打印出的结果分别是8和12。
那么一个类或者说对象占用的内存到底怎么计算呢?以Base为例,首先成员变量m_b占用了4个字节,其次,由于m_funcB是虚函数,因此要有一张虚函数表,其实就是一个指向表的指针,无论是什么类型的指针,占用的大小总是4字节,因此base占用了8个字节的大小。而Derived除了继承了Base的成员m_b之外,也保存了虚函数表的地址,还有自己的成员变量m_d,所以占用了12个字节。
或者有人会问:构造函数呢?还有虚函数本身不是还有函数体吗?难道不用计算进去?确实,类的函数是不会存储在实例化出来的对象里的,试想,对于每个对象,函数实现都是一样的,如果每实例化一个对象就存储一次函数体,不是毫无必要并且对内存使用而言是极大的浪费?
函数编译出来后是作为代码的一部分放在代码段中的,因此只要我们定义了Derived指针,无论这个实际指针指向什么对象,由于程序“事先”已经知道了这个方法属于哪个类,只要指针的类型正确,都可以正确找到调用函数的入口。所以即使我们的代码这么写,也是可以正确运行的:

void * p2 = (int*)0;
Derived* p3= (Derived*)p2;
cout << p3->m_funcD() << endl;

不管把什么地址赋给p2,都能正确地执行m_funcD函数。当然如果p3定义成其他类型,那么编译就会出错。
如果执行以下代码:

void * p2 = (int*)0;
Derived* p3= (Derived*)p2;
cout << p3->m_d << endl;

那么程序就会出现错误了,因为和成员函数不同,成员变量是每个对象都会在内存中用实际的内存地址存储,所以说成员函数属于类,成员变量属于各自的对象。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页