如何实现C++中Car类族对象传入User类的通用设计？

你的代码报错核心原因是User类里的Car car是值类型对象，赋值子类对象时会发生「对象切片」——Toyota对象会被截断成纯Car类型，不仅丢失子类特性，而且你想要的「持有任意Car子类」的需求根本无法通过值类型实现。

下面是正确的实现方案：

第一步：修正基类，启用多态 #

要让子类重写的方法生效，必须把基类的方法声明为虚函数，同时添加虚析构函数避免内存泄漏：

#include <iostream>
#include <memory> // 智能指针需要的头文件

class Car
{
public:
    Car() = default;
    // 虚析构：确保子类对象通过基类指针销毁时能正确调用子类析构
    virtual ~Car() = default;
    // 虚函数：允许子类重写，实现多态
    virtual void method1() {
        std::cout << "默认Car方法" << std::endl;
    }
};

class Toyota : public Car
{
public:
    Toyota() = default;
    // override关键字明确标记重写基类虚函数，避免写错函数签名
    void method1() override {
        std::cout << "Toyota专属方法" << std::endl;
    }
};

class Lada : public Car
{
public:
    Lada() = default;
    void method1() override {
        std::cout << "Lada专属方法" << std::endl;
    }
};

第二步：修改User类，使用指针/智能指针持有Car对象 #

值类型无法实现多态，必须改用指针或智能指针来持有子类对象，这里推荐用智能指针（自动管理内存，避免泄漏）：

方案1：使用std::unique_ptr（推荐） #

class User
{
public:
    User() = default;

    // 设置车辆：传入unique_ptr，转移所有权
    void setCar(std::unique_ptr<Car> vehicle) {
        car = std::move(vehicle);
    }

    // 使用车辆，调用对应子类的方法
    void useCar() {
        if (car) {
            car->method1();
        }
    }

private:
    std::unique_ptr<Car> car; // 智能指针，自动管理内存
};

int main()
{
    User user;
    // 传入Toyota对象
    user.setCar(std::make_unique<Toyota>());
    user.useCar(); // 输出：Toyota专属方法

    // 换成Lada对象
    user.setCar(std::make_unique<Lada>());
    user.useCar(); // 输出：Lada专属方法

    return 0;
}

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

如果必须用原始指针，要注意手动释放内存，避免泄漏：

class User
{
public:
    User() : car(nullptr) {}
    // 析构时释放内存
    ~User() {
        delete car;
    }
    // 禁用拷贝构造和赋值，避免浅拷贝导致重复释放
    User(const User&) = delete;
    User& operator=(const User&) = delete;

    void setCar(Car* vehicle) {
        delete car; // 先释放原有车辆
        car = vehicle;
    }

    void useCar() {
        if (car) {
            car->method1();
        }
    }

private:
    Car* car;
};

int main()
{
    User user;
    user.setCar(new Toyota());
    user.useCar(); // 输出Toyota专属方法

    user.setCar(new Lada());
    user.useCar(); // 输出Lada专属方法

    return 0;
}

关键知识点说明 #

• 虚函数与多态：基类的virtual关键字标记方法后，子类用override重写，通过基类指针/引用调用时，会自动匹配实际指向的子类对象的方法。
• 对象切片：当用子类对象赋值给基类值对象时，子类特有的数据和方法会被丢弃，最终得到的只是一个纯基类对象，无法实现多态。
• 虚析构的必要性：如果用基类指针指向子类对象，销毁时若基类没有虚析构，只会调用基类的析构函数，导致子类的资源无法释放，引发内存泄漏。
• 智能指针优势：std::unique_ptr自动管理内存生命周期，无需手动调用delete，同时避免了原始指针的浅拷贝问题。

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