C++ 使用基类和派生类编写虚拟序列化函数

我正在做一个处理汽车库存的项目。有一个基本车辆类别和一个派生的AdvancedVehicle类别。我的序列化函数遇到了一个问题，它是一个虚拟函数。似乎每当基类或派生类调用函数时，它只运行基类序列化函数。随附车辆和AdvancedVehicle类定义和实现

/////////////////////////////// VEHICLE //////////////////////////////////
class Vehicle{
    friend ostream& operator<< (ostream& os, const Vehicle v) {
            v.Serialize(os);
            return os;
    }
public:
    Vehicle() = delete;
    Vehicle(string model, size_t year, float price) {
        m_model = model;
        m_year = year;
        m_baseprice = price;
        m_owner = NULL;
    }
    Vehicle(string model, size_t year, float price, const Client* owner) {
        m_model = model;
        m_year = year;
        m_baseprice = price;
        m_owner = new Client("");
        *m_owner = *owner;
    }
    Vehicle(const Vehicle& otherVehicle) {
        m_model = otherVehicle.m_model;
        m_year = otherVehicle.m_year;
        m_baseprice = otherVehicle.m_baseprice;
        m_owner = NULL;
    }
    Vehicle& operator= (const Vehicle& otherVehicle) {
        m_model = otherVehicle.m_model;
        m_year = otherVehicle.m_year;
        m_baseprice = otherVehicle.m_baseprice;
        m_owner = new Client("");
        *m_owner = *otherVehicle.m_owner;
        return *this;
    }
    void setPrice(float price) {
        m_baseprice = price;
    }
    void SetOwner(const Client* owner) {
        m_owner = new Client("");
        if(owner)
        {
            *m_owner = *owner;
        }
    }
    string GetModel() const { return m_model; }
    size_t GetYear() const { return m_year; }
    virtual float GetPrice() const { return m_baseprice; }
    Client* GetOwner() const { return m_owner; }
    virtual void Serialize(ostream& os) const {
        os << m_year << " ";
        os << m_model << " ";
        os << m_baseprice << " ";
        if(m_owner != NULL)
        {
            os << *m_owner << endl;
        }
    }
protected:
    string m_model;
    size_t m_year;

private:
 float m_baseprice;
 Client* m_owner;
};



/////////////////////////// ADVANCEDVEHICLE ///////////////////////////////
class AdvancedVehicle : public Vehicle{
    friend ostream& operator<< (ostream& os, const AdvancedVehicle AV) {
        AV.Serialize(os);
        return os;
    }
public:
    AdvancedVehicle() = delete;
    AdvancedVehicle(string model, size_t year, float price, vector<Sensor> sensors, const Client* owner):Vehicle (model, year, price){
        m_model = model;
        m_year = year;
        SetOwner(owner);
        setPrice(price);
        for(auto i = sensors.begin(); i != sensors.end(); i++)
        {
            int j = 0;
            AddSensor(sensors[j]);
            j++;
        }
    }
    AdvancedVehicle(string model, size_t year, float price, vector<Sensor> sensors):Vehicle (model, year, price){
        m_model = model;
        m_year = year;
        SetOwner(NULL);
        setPrice(price);
        for(auto i = sensors.begin(); i != sensors.end(); i++)
        {
            int j = 0;
            AddSensor(sensors[j]);
            j++;
        }
    }
    AdvancedVehicle(const AdvancedVehicle& otherAV):Vehicle( otherAV) {
        m_model = otherAV.m_model;
        m_year = otherAV.m_year;
        m_finalprice = otherAV.m_finalprice;
        SetOwner(NULL);
        for(auto i = otherAV.m_sensors.begin(); i != otherAV.m_sensors.end(); i++)
        {
            int j = 0;
            AddSensor(otherAV.m_sensors[j]);
            j++;
        }
    }
    AdvancedVehicle& operator=(const AdvancedVehicle& otherAV) {
        m_model = otherAV.m_model;
        m_year = otherAV.m_year;
        setPrice(otherAV.GetPrice());
        SetOwner(otherAV.GetOwner());
        for(auto i = otherAV.m_sensors.begin(); i != otherAV.m_sensors.end(); i++)
        {
            int j = 0;
            AddSensor(otherAV.m_sensors[j]);
            j++;
        }

        return *this;
    }
    void AddSensor(Sensor addedSensor) {
        m_sensors.push_back(addedSensor);
        m_finalprice += addedSensor.GetPrice();
    }
    virtual float GetPrice() const { return m_finalprice; }
    virtual void Serialize(ostream& os) const {
        os << m_year << " ";
        os << m_model << " ";
        os << m_finalprice << " ";
        if(GetOwner() != NULL)
        {
            os << GetOwner() << " ";
        }
        for(auto i = m_sensors.begin(); i != m_sensors.end(); i++)
        {
            os << &i << " ";
        }
        os << endl;
    }

private:
    vector<Sensor> m_sensors;
    float m_finalprice;
};

//车辆//////////////////////////////////
等级车辆{
friend ostream&operator您的程序正遭受此问题。
operator怀疑这是重现此问题所需的最短代码。要确保派生类重写您的虚拟函数，请使用“override”关键字。请用调用的对象显示代码。
序列化
。文章中有太多与核心问题无关的内容。发布的咒语应该是mcve，mcve，mcve（）。const reference（
const Vehicle&
）。此外，不应该有
操作符的向下投票，因为这是一个非常糟糕的问题。（OP没有显示对序列化的调用，他们也没有尝试最小化示例）。回答这样的问题，只会鼓励他们。