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

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;

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

以上就是小编为大家带来的由static_cast和dynamic_cast到C++对象占用内存的全面分析全部内容了，希望大家多多支持我们~