大编辑

因此，在收集了大家的一些反馈并思考了 XY problem 之后正如 Zack 所建议的，我决定添加另一个代码示例来准确说明我要完成的任务(即“X”)，而不是询问我的“Y”。

现在我们正在处理汽车，我添加了 5 个抽象类:ICar、ICarFeatures、ICarParts、ICarMaker ，ICarFixer。所有这些接口(interface)都将包装或使用第三方库提供的技术特定的复杂对象，具体取决于接口(interface)背后的派生类。这些接口(interface)将智能地管理复杂库对象的生命周期。

我的用例是 FordCar 类。在此示例中，我使用 Ford 库访问类 FordFeatureImpl、FordPartsImpl 和 FordCarImpl。这是代码:

class ICar {
public:
    ICar(void) {}
    virtual ~ICar(void) {}
};

class FordCar : public ICar {
public:
    ICar(void) {}
    ~FordCar(void) {}
    FordCarImpl* _carImpl;
};

class ICarFeatures {
public:
    ICarFeatures(void) {}
    virtual ~ICarFeatures(void) {}
    virtual void addFeature(UserInput feature) = 0;
};

class FordCarFeatures : public ICarFeatures{
public:
    FordCarFeatures(void) {}
    virtual ~FordCarFeatures(void) {}
    virtual void addFeature(UserInput feature){

        //extract useful information out of feature, ie:
        std::string name = feature.name;
        int value = feature.value;
        _fordFeature->specialAddFeatureMethod(name, value);
    }

    FordFeatureImpl* _fordFeature;
};

class ICarParts {
public:
    ICarParts(void) {}
    virtual ~ICarParts(void) {}
    virtual void addPart(UserInput part) = 0;
};

class FordCarParts :public ICarParts{
public:
    FordCarParts(void) {}
    virtual ~FordCarParts(void) {}
    virtual void addPart(UserInput part) {

        //extract useful information out of part, ie:
        std::string name = part.name;
        std::string dimensions = part.dimensions;
        _fordParts->specialAddPartMethod(name, dimensions);
    }
    FordPartsImpl* _fordParts;
};

class ICarMaker {
public:
    ICarMaker(void) {}
    virtual ~ICarMaker(void) {}
    virtual ICar* makeCar(ICarFeatures* features, ICarParts* parts) = 0;
};

class FordCarMaker {
public:
    FordCarMaker(void) {}
    virtual ~FordCarMaker(void) {}
    virtual ICar* makeCar(ICarFeatures* features, ICarParts* parts){

        FordFeatureImpl* fordFeatures = dynamic_cast<FordFeatureImpl*>(features);
        FordPartsImpl* fordParts = dynamic_cast<FordPartsImpl*>(parts);

        FordCar* fordCar = customFordMakerFunction(fordFeatures, fordParts);

        return dynamic_cast<ICar*>(fordCar);
    }

    FordCar* customFordMakerFunction(FordFeatureImpl* fordFeatures, FordPartsImpl* fordParts) {

        FordCar* fordCar =  new FordCar;

        fordCar->_carImpl->specialFeatureMethod(fordFeatures);
        fordCar->_carImpl->specialPartsMethod(fordParts);

        return fordCar;
    }
};


class ICarFixer {
public:
    ICarFixer(void) {}
    virtual ~ICarFixer(void) {}
    virtual void fixCar(ICar* car, ICarParts* parts) = 0;
};


class FordCarFixer {
public:
    FordCarFixer(void) {}
    virtual ~FordCarFixer(void) {}
    virtual void fixCar(ICar* car, ICarParts* parts) {

        FordCar* fordCar = dynamic_cast<FordCar*>(car);
        FordPartsImpl* fordParts = dynamic_cast<FordPartsImpl*>(parts);

        customFordFixerFunction(fordCar, fordParts);


}

customFordFixerFunction(FordCar* fordCar, FordPartsImpl* fordParts){
    fordCar->_carImpl->specialRepairMethod(fordParts);
}
};

请注意，我必须使用动态转换来访问抽象接口(interface)中特定于技术的对象。这就是让我觉得我在滥用继承权并促使我最初提出这个问题的原因。

这是我的最终目标:

UserInput userInput = getUserInput(); //just a configuration file ie XML/YAML
CarType carType = userInput.getCarType();

ICarParts* carParts = CarPartFactory::makeFrom(carType);
carParts->addPart(userInput);

ICarFeatures* carFeatures = CarFeaturesFactory::makeFrom(carType);
carFeatures->addFeature(userInput);

ICarMaker* carMaker = CarMakerFactory::makeFrom(carType);
ICar* car = carMaker->makeCar(carFeatures, carParts);

UserInput repairSpecs = getUserInput();
ICarParts* replacementParts = CarPartFactory::makeFrom(carType);
replacementParts->addPart(repairSpecs);

ICarFixer* carFixer = CarFixerFactory::makeFrom(carType);
carFixer->fixCar(car, replacementParts);

也许现在你们都对我正在尝试做的事情以及我可以改进的地方有了更好的理解。

我正在尝试使用基类的指针来表示派生类(即 Ford)，但是派生类包含其他派生类(即FordCarFixer 需要一个 FordCar 和 FordPartsImpl 对象)。这需要我使用动态转换将指针从基类向下转换到其各自的派生类，以便我可以访问这些特定的 Ford 对象。

最佳答案

我的问题是:我在这里滥用继承吗？我试图在 worker 和对象之间建立多对多关系。我觉得我做错了什么，因为有一个 Object 类系列，它实际上除了保存数据什么都不做，并且使 ObjectWorker 类必须 dynamic_cast 对象才能访问内部。

那不是滥用继承...这是滥用继承

class CSNode:public CNode, public IMvcSubject, public CBaseLink,
         public CBaseVarObserver,public CBaseDataExchange, public CBaseVarOwner

其中有 C 前缀的有大量的实现

不仅如此... Header 超过 300 行声明。

所以不......你现在没有滥用继承。

但是我刚刚向您展示的这个类是侵 eclipse 的产物。我确信 Node 一开始就是一个 Shiny 的灯塔和多态性，能够在行为和节点之间巧妙切换。

现在它变成了 Kraken，Megamoth，Cthulu 本身试图咀嚼我的内脏，只看到它。

听从这个自由人，听从我的忠告，小心你的多态性会变成什么样子。

否则它很好，很好地使用了我认为是尿布中的架构的东西的继承。

如果我只想使用一个 work() 方法，我还有哪些其他选择？

单一工作方法...您可以尝试:

• 基于策略的设计，其中策略实现了您的模型
• 每个类都使用的函数“工作”
• 一个仿函数!在将要使用的每个类中实例化

但是您的继承似乎是正确的，每个人都会使用的单一方法。

还有一件事....我要留下这个维基链接right here

或者可能只是复制粘贴 wiki C++ 代码...这与您的代码非常相似:

#include <iostream>
#include <string>
 
template <typename OutputPolicy, typename LanguagePolicy>
class HelloWorld : private OutputPolicy, private LanguagePolicy
{
    using OutputPolicy::print;
    using LanguagePolicy::message;
 
public:
    // Behaviour method
    void run() const
    {
        // Two policy methods
        print(message());
    }
};
 
class OutputPolicyWriteToCout
{
protected:
    template<typename MessageType>
    void print(MessageType const &message) const
    {
        std::cout << message << std::endl;
    }
};
 
class LanguagePolicyEnglish
{
protected:
    std::string message() const
    {
        return "Hello, World!";
    }
};
 
class LanguagePolicyGerman
{
protected:
    std::string message() const
    {
        return "Hallo Welt!";
    }
};
 
int main()
{
    /* Example 1 */
    typedef HelloWorld<OutputPolicyWriteToCout, LanguagePolicyEnglish> HelloWorldEnglish;
 
    HelloWorldEnglish hello_world;
    hello_world.run(); // prints "Hello, World!"
 
    /* Example 2 
     * Does the same, but uses another language policy */
    typedef HelloWorld<OutputPolicyWriteToCout, LanguagePolicyGerman> HelloWorldGerman;
 
    HelloWorldGerman hello_world2;
    hello_world2.run(); // prints "Hallo Welt!"
}

更重要的问题是

您将如何在 StringWorker 中使用 Int 对象？

您当前的实现将无法处理该问题

有了政策，这是可能的。

可能的对象是什么？

帮助您定义是否需要这种行为

记住，不要用霰弹 Gunicorn 鸡

也许你的模型永远不会真正改变加类。

关于c++ - 我在这里滥用继承吗？什么是最佳实践替代方案/模式？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22051876/