C++运行时指定对象类型：基于继承从基类创建具体对象的方案咨询

这是C++里典型的**对象切片（Object Slicing）**问题，咱们一步步拆解原因，再给出靠谱的解决方案~

为什么你的代码会输出"Base Material Class"？ #

你遇到的核心问题是：C++里当你把子类对象赋值给基类类型的变量（或者按值传递参数）时，子类对象中属于自身的部分会被"切掉"，只剩下基类的部分，也就是所谓的对象切片。

看你的main函数：

Material material = Wood();

这行代码已经把Wood对象切片成了Material对象，后续传给setMaterial的本来就是纯基类实例，自然调用的是基类的print方法。而且你的setMaterial参数是值传递：

void setMaterial(Material material){ this->material = material; }

就算你直接传Wood()进去，也会在参数传递时被切片成Material，所以无论如何，Furniture里存储的都是基类对象，多态根本没法生效。

解决方案：用指针或智能指针实现多态 #

C++的多态必须依赖指针或引用才能生效，因为只有这样才能保留子类对象的完整信息，让程序在运行时识别实际的对象类型。这里推荐两种方案：

方案1：使用原始指针（需要手动管理内存） #

修改Furniture的成员变量和setMaterial方法，换成指针类型，同时要给基类添加虚析构函数（避免内存泄漏）：

#include <iostream>
using namespace std;

class Material{
public:
    virtual void print(){ cout << "Base Material Class" << endl; }
    virtual ~Material() {} // 必须加虚析构，否则子类对象无法被正确销毁
};

class Wood: public Material{
public:
    void print(){ cout << "Wood Material" << endl; }
};

class Furniture{
public:
    void setMaterial(Material* mat){ 
        this->material = mat; 
    }
    virtual void print(){ 
        if(material != nullptr) // 空指针检查，避免崩溃
            material->print(); 
    }
protected:
    Material* material = nullptr; // 初始化空指针，防止野指针
};

class Chair: public Furniture{
    // 这里可以添加Chair特有的属性或方法
};

int main(int argc, char** argv){
    Chair aChair;
    Wood wood; // 栈上的Wood对象，生命周期和main函数一致
    aChair.setMaterial(&wood);
    aChair.print(); // 现在会输出"Wood Material"

    // 如果需要动态分配对象（比如对象生命周期更长）：
    // Material* steelPtr = new Steel(); // 假设你有Steel类
    // aChair.setMaterial(steelPtr);
    // aChair.print();
    // delete steelPtr; // 记得手动释放内存，否则会泄漏
}

方案2：使用智能指针（推荐，安全无需手动管理内存） #

如果不想手动管理内存，用C++11引入的智能指针std::unique_ptr或std::shared_ptr是更好的选择，它们会自动在对象生命周期结束时释放内存：

#include <iostream>
#include <memory> // 引入智能指针头文件
using namespace std;

class Material{
public:
    virtual void print(){ cout << "Base Material Class" << endl; }
    virtual ~Material() {}
};

class Wood: public Material{
public:
    void print(){ cout << "Wood Material" << endl; }
};

class Furniture{
public:
    // 用move语义转移智能指针的所有权
    void setMaterial(unique_ptr<Material> mat){ 
        this->material = move(mat); 
    }
    virtual void print(){ 
        if(material != nullptr)
            material->print(); 
    }
protected:
    unique_ptr<Material> material;
};

class Chair: public Furniture{};

int main(int argc, char** argv){
    Chair aChair;
    // 直接创建Wood的智能指针并传递
    aChair.setMaterial(make_unique<Wood>());
    aChair.print(); // 输出"Wood Material"

    // 切换成Steel类型也很方便
    // aChair.setMaterial(make_unique<Steel>());
    // aChair.print();
}

补充说明 #

• 为什么需要虚析构函数？当用基类指针指向子类对象时，如果基类没有虚析构，delete指针只会调用基类的析构函数，子类的析构逻辑不会执行，会导致内存泄漏。
• 引用也能实现多态，但引用必须初始化且不能重新绑定，所以对于setMaterial这种需要后续修改的场景，指针或智能指针更灵活。

内容的提问来源于stack exchange，提问作者Viet Tran