将下一个 C++ 类作为问题的简化:

struct Car
{
    virtual int get_price() = 0;
};

struct ExpensiveCar: public Car
{
    int get_price( ) {/*..*/ }
    void apply_turbo( ){/*..*/};
};

struct CheapCar: public Car
{
    int get_price( ) {/*..*/}
};

struct CarRetailer
{
    virtual std::vector<Car*> get_cars( ) = 0;
};


struct ExpensiveCarsRetailer : public CarRetailer
{
    virtual std::vector<Car*> get_cars( ) { /*..*/ }
    std::vector<ExpensiveCar*> get_cars_for_exhibitions( );
};

struct CheapCarsRetailer : public CarRetailer
{
    virtual std::vector<Car*> get_cars( ) { /*..*/ }
    std::vector<CheapCar*> get_second_hand_cars( );
};

规则是:昂贵的汽车仅在 ExpensiveCarsRetailers 中出售(与廉价汽车类似)。便宜的车没有涡轮，贵的车不卖二手。

我在这里面临的问题是包含继承类的类的耦合。因此，如果 ExpensiveCarRetailer继承自 CarRetailer , 它需要实现 virtual std::vector<Car*> get_cars( )这实际上是返回 Car* 的 vector ，然而，在内部ExpensiveCarRetailer只创建了 ExpensiveCar 的对象.此外，get_cars_for_exhibitions()不包含在公共(public)接口(interface)中CarRetailer因此，它可以返回 std::vector<ExpensiveCar*>相反。

API 中的混合(Car* 和ExpensiveCar* 的返回 vector )非常丑陋，用户使用apply_turbo( ) 需要编写的代码也是如此。特定汽车列表的功能ExpesiveCarsRetailer .

ExpensiveCarsRetailer ferrari;

std::vector<Car*> car = ferrari.get_cars();
ExpensiveCar* expensive_car;
for( int i = 0; i < car.size( ); ++i)
{
expensive_car = dynamic_cast<ExpensiveCar*>(car[i]);
expensive_car->apply_turbo();
}

我确信我遗漏了一些在这种情况下有帮助的设计模式，其中类继承树的耦合方式是其中一个继承树的抽象类需要返回一个 vector (或集合、列表、等)的其他继承树上的类。我尽量避免动态转换。

我也想过制作CarRetailer一个模板类，因此:

template<typename T>
    struct CarRetailer
    {
        virtual std::vector<T*> get_cars( ) = 0;
    };

然后制作:

struct ExpensiveCarRetailer: public CarRetailer<ExpensiveCar>
{
...
}

但我认为这行不通，因为例如 CarRetailer也可以开始销售摩托车(类似于汽车的结构)或自行车等(始终应用昂贵/廉价模式)，最终需要在 CarRetailer 中定义的模板类的数量将是巨大的。

最佳答案

“也包含继承类的类耦合”的整个概念称为协变。在维基百科上可以找到对该主题的广泛评论:http://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science) .但是让我们回到实际的例子:通过写

struct CarRetailer
{
    virtual std::vector<Car*> get_cars( ) = 0;
};

你 promise 的太多了，即 get_cars()函数将返回一个 vector ，您可以使用任何 Car 对其进行修改你要。这可能不是你的意思:

CarRetailer* ferrari = new ExpensiveCarsRetailer();
auto niceCars ferrari->get_cars();
niceCars.push_back(new Car{"Trabant"}); // you promised in the declaration that it was possible!

解决方案是减少您在根类中所做的“ promise ”，返回一个不能被“无关”对象更改的范围。一个只读的容器会很好，但遗憾的是，C++ 还没有(还？)智能到支持它的协变性:

struct CarRetailer
{
    virtual const std::vector<const Car*> get_cars( ) = 0;
};

struct ExpensiveCarsRetailer : public CarRetailer 
{
    const std::vector<const ExpensiveCar*> get_cars( ) = 0;
    // Alas, it won't override
};

但是范围(即指针对，希望 C++17 能提供更好的东西)可以:

struct CarRetailer
{
    virtual Car* const cars_begin( ) = 0;
    virtual Car* const cars_end( ) = 0;
};

struct ExpensiveCarsRetailer : public CarRetailer 
{
    ExpensiveCar* const cars_begin( ) override {return cars->begin();}
    ExpensiveCar* const cars_end( ) override {return cars->end();}

    private:
    vector<ExpensiveCar>* cars; 
};

(注意:我没有测试我的代码，所以请原谅可能的错误。但概念应该很清楚)

这个界面可能看起来比原来的界面更难看，但我的看法恰恰相反，因为它与强大的<algorithm>完美结合。 C++ 库并有助于以现代风格编写代码。这里有一个简单的例子:

any_of(dealer.cars_begin( ), dealer.cars_end( ),
       [](const auto& car) -> bool {return car.hasScratch();}
) ? complain() : congratulate();

这种设计最大的缺点是CarDealer类必须拥有 *cars容器并管理它的存在，即它必须关心它返回的指针保持事件状态。由于 C++ does not support covariance on them 不能返回智能指针这一事实使这变得很困难。 .此外，最终可能不得不维护一个 vector<Car>* 的容器。 , 如果 cars_begin和 cars_end函数应该在重复调用时生成新的集合。因此，您需要根据您的具体用例来权衡我的建议的利弊。

就个人而言，如果我遇到同样的问题，我会使用模板化类并完全避免继承:恕我直言，此类问题很好地说明了为什么 OOP 有时会使事情复杂化而不是简化它们。

编辑

如果我很好理解为什么你觉得模板化的Dealers不会被指定为你的需求，我认为这个建议应该更合适:

struct ExpensiveCarsRetailer /* not derived, not templated */
{
    std::vector<ExpensiveCar> get_cars( ) { /*..*/ }
    // you can also return a vector of pointers or of unique_pointers, as you feel like.
};

struct CheapCarsRetailer /* not derived, not templated */
{
    std::vector<CheapCar> get_cars( );
};

使用模板函数代替重载:

template <typename T> print_car_table(T dealer) {
    // This will work on both Expensive and Cheap dealers

    // Not even a hierarchy for the Car classes is needed:
    // they can be independent structs, like the Dealer ones

    auto cars = dealer.get_cars();

    for (const auto& car : cars) { std::cout << car.name() << "\t" << car.color() << "\n"; }
}

template <typename T> apply_turbo(T dealer) {
    // This will work if dealer is an ExpensiveDealer,
    // and fail on compile time if not, as wanted

    auto cars = dealer.get_cars();

    for (auto& car : cars) { car.apply_turbo(); }
}

这个系统最大的好处就是你甚至不用提前规划接口(interface)，每个类都可以只实现你需要的方法。因此，如果将来您添加 CarMuseum , 你可以决定实现 get_cars()得到print_car_table(T)使用它，但您可以自由地不创建任何其他方法。通过继承，您将被迫实现在基接口(interface)中声明的所有功能，或者创建许多零散的接口(interface)(class CheapDealer : public HasACarList, public HasAPriceList, /* yuck ...*/)。 .

这种模板化设计的缺点是 Dealer 类不是亲戚。这意味着您无法创建 vector<Dealer>也没有Dealer* (即使您使它们派生自一个微小的通用接口(interface)，您也无法通过指向此类接口(interface)的指针调用 get_cars())。

为了完整起见，我会指出相反的动态解决方案:

struct Car {
    virtual int get_price() = 0;
    virtual void apply_turbo( ) = 0;
};

struct CheapCar: public Car
{
    int get_price( ) {/*..*/}
    void apply_turbo( ){throw OperationNonSupportedException();};
};

感觉 C++ 不是很地道，是吗？我觉得它很不雅观，但我仍然认为在丢弃它之前应该评估这个设计。优点和缺点或多或少与模板化解决方案相反。

最后，我想访问者模式或 Scala(提供非常强大的协方差工具)可以为您的问题提供其他替代解决方案。但是我对它们都没有经验，所以我留给其他人来说明。

关于c++ - 继承包含另一个派生类的 C++ 类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30360189/