C++ 动态理解

我最近开始了动态和静态演播。我确实有点了解在静态_cast中发生了什么，但在动态_cast中没有。我所知道的最多的是，静态_-cast可以用来转换数据类型，并且不检查编译时，而动态_-cast可以。我还使用DynamicCast编写了a代码，但我不确定它们之间的关系。 这是我的密码

#include <iostream>
using namespace std;

class Base{
public:
    virtual void setting(){
        cout << "Hello, I am a function from the base class" << endl;
    }
    virtual void say(){
        cout << "Base class says hi" << endl;
    }
};

class Child:public Base{
public:
    void setting(){
        cout << "Hello, I am a function from the child class" << endl;
    }
    void say(){
        cout << "Child class says hi" << endl;
    }
};

class Child2:public Base{
public:
    void setting(){
        cout << "Hello, I am a function from the child2 class" << endl;
    }
    void say(){
        cout << "Child class says Wazuppppp" << endl;
    }
};
void start(Base* bp){ //here is where I get confused
    Child* it_is_Child= dynamic_cast<Child*>(bp);
    if(it_is_Child){
        it_is_Child->say();
        it_is_Child->setting();
    }
    Child2* it_is_child2= dynamic_cast<Child2*>(bp);
    if(it_is_child2){ //then
        it_is_child2->say();
        it_is_child2->setting();
    }
};

int main(){
    Child cp1;
    Child2 cp2;
    start(&cp2);
    cout << endl;
    start(&cp1);
    system("pause");


    return 0;
 }

#包括
使用名称空间std；
阶级基础{
公众：
虚拟空设置（）{
cout不是由编译器决定哪一个。使用，编译器在
子对象
的对象中添加一些额外信息（另一个隐式属性），这些信息记录了对象的实际类。可以使用
typeid
检索这些额外信息。然后用于调用

Child* child = dynamic_cast<Child*>(bp);

注意：我在这里过于简化了。实际上，
dynamic\u cast
在超类的整个格中做了一些更复杂的事情。
不是由编译器决定哪一个。通过使用，编译器在
子对象中添加了一些额外的信息（另一个隐式属性）它记录对象的实际类。可以使用
typeid
检索此额外信息。然后用于调用

Child* child = dynamic_cast<Child*>(bp);

注意：我在这里过于简化了。实际上，
dynamic\u cast
在超类的整个格中做了一些更复杂的事情。
不是由编译器决定哪一个。通过使用，编译器在
子对象中添加了一些额外的信息（另一个隐式属性）它记录对象的实际类。可以使用
typeid
检索此额外信息。然后用于调用

Child* child = dynamic_cast<Child*>(bp);

注意：我在这里过于简化了。实际上，
dynamic\u cast
在超类的整个格中做了一些更复杂的事情。
不是由编译器决定哪一个。通过使用，编译器在
子对象中添加了一些额外的信息（另一个隐式属性）它记录对象的实际类。可以使用
typeid
检索此额外信息。然后用于调用

Child* child = dynamic_cast<Child*>(bp);

注意：我在这里过于简化了。实际上，
dynamic\u cast
在超类的整个格中做了更复杂的事情。
在这种特殊情况下，如果不使用
dynamic\u cast
（事实上，当您拥有从基类继承的对象时，您通常会这样做。）换句话说：

void start(Base* bp){ //here is where I get confused
   bp->say();
   bp->setting();
};

将调用正确的
say
和
设置
（在本例中，如果使用
base
对象调用，当然也会从
base
输出）

举个例子来说，
child2
，它的功能集与其他类不同，这会更有趣

因此，如果我们这样做：

class Child2:public Base{
public:
    void setting(){
        cout << "Hello, I am a function from the child2 class" << endl;
    }
    void say(){
        cout << "Child class says Wazuppppp" << endl;
    }
    void special() {
        cout << "Special function called" << endl;
    }
};

dynamic\u cast
的工作方式是编译器生成代码，在运行时“查看”输入并确定其是否为“正确类型”（即，该类以正确的方式与要强制转换的类相关）。通常，为了方便起见，它通过查看对象vtable来完成此操作，因为具有相同基类的类具有可匹配的vtable。在某些实现中，使用RTTI（运行时类型信息），但大多数实现使用“vtable”方法

一般来说，在使用继承时，应该谨慎地使用
dynamic\u cast
（以及类型之间的其他类型转换）（并且“始终”检查结果）。
在这种特殊情况下，如果不使用
dynamic\u cast
（事实上，当您拥有从基类继承的对象时，您通常会这样做。）换句话说：

void start(Base* bp){ //here is where I get confused
   bp->say();
   bp->setting();
};

将调用正确的
say
和
设置
（在本例中，如果使用
base
对象调用，当然也会从
base
输出）

举个例子来说，
child2
，它的功能集与其他类不同，这会更有趣

因此，如果我们这样做：

class Child2:public Base{
public:
    void setting(){
        cout << "Hello, I am a function from the child2 class" << endl;
    }
    void say(){
        cout << "Child class says Wazuppppp" << endl;
    }
    void special() {
        cout << "Special function called" << endl;
    }
};

dynamic\u cast
的工作方式是编译器生成代码，在运行时“查看”输入并确定其是否为“正确类型”（即，该类以正确的方式与要强制转换的类相关）。通常，为了方便起见，它通过查看对象vtable来完成此操作，因为具有相同基类的类具有可匹配的vtable。在某些实现中，使用RTTI（运行时类型信息），但大多数实现使用“vtable”方法

一般来说，在使用继承时，应该谨慎地使用
dynamic\u cast
（以及类型之间的其他类型转换）（并且“始终”检查结果）。
在这种特殊情况下，如果不使用
dynamic\u cast
（事实上，当您拥有从基类继承的对象时，您通常会这样做。）换句话说：

void start(Base* bp){ //here is where I get confused
   bp->say();
   bp->setting();
};

将调用正确的
say
和
设置
（在本例中，如果使用
base
对象调用，当然也会从
base
输出）

举个例子来说，
child2
，它的功能集与其他类不同，这会更有趣

因此，如果我们这样做：

class Child2:public Base{
public:
    void setting(){
        cout << "Hello, I am a function from the child2 class" << endl;
    }
    void say(){
        cout << "Child class says Wazuppppp" << endl;
    }
    void special() {
        cout << "Special function called" << endl;
    }
};

dynamic\u cast
的工作方式是编译器生成代码，在运行时“查看”输入并确定其是否为“正确类型”（即，该类以正确的方式与要强制转换的类相关）。通常，为了方便起见，它通过查看对象vtable来实现这一点，因为具有相同基类的类具有可以