c++ - 关于多态性的基本问题。基类的 vector ，要派生类。如何？

Question

我想我的设计搞砸了，因为我想保留各种对象类型的 vector 。这些类型都共享一个公共(public)基类。示例:

Class Buick: AmericanCar
{
}

Class Ford: AmericanCar
{
}

然后我做了:

vector<AmericanCar*> cars_i_own;

现在，我有了我的指针 vector ，但我没有我需要的派生类。我考虑过在基类中添加一个 GetType/SetType 函数，然后使用动态转换。虽然这很笨重。我是否为此使用了错误的设计？

Answer 1

好吧，你想用它做什么？获取名称或成本？你会有这样的东西:

class Car
{
public:
    virtual ~Car(void) {}

    virtual std::string location(void) const = 0;
    virtual std::string name(void) const = 0;
    virtual double cost(void) const = 0;
}

class AmericanCar
{
public:
    virtual ~AmericanCar(void) {}

    virtual std::string location(void) const
    {
        return "America";
    }
}

class Buick : public AmericanCar
{
public:
    virtual std::string name(void) const
    {
        return "Buick";
    }

    virtual double cost(void) const
    {
        return /* ... */;
    }
}

class Ford : public AmericanCar
{
public:
    virtual std::string name(void) const
    {
        return "Ford";
    }

    virtual double cost(void) const
    {
        return /* ... */;
    }
}

现在您可以多态地调用这些方法。

不过，这有点奇怪。您不需要像这样存储名称和成本的不同类:

class Car
{
public:
    Car(const std::string& pLocation,
        const std::string& pName,
        double pCost) :
    mLocation(pLocation),
    mName(pName),
    mCost(pCost)
    {
    }

    const std::string& location(void) const
    {
        return mLocation;
    }

    void location(const std::string& pLocation)
    {
        mLocation = pLocation;
    }

    const std::string& name(void) const
    {
        return mName;
    }

    void name(const std::string& pName)
    {
        mName = pName;
    }

    const double cost(void) const
    {
        return mCost;
    }

    void cost(double pCost)
    {
        mCost = pCost;
    }

private:
    std::string mLocation;
    std::string mName;
    double mCost;
}

// make cars
std::vector<Car> cars;
cars.push_back(Car("America", "Buick", /* ... */));