C++协变参数 - 设计模式

Question

以下面简化的C++类层次结构为例。我想要完成的是Service提供了一种虚拟方法来保存任意的对象。但是Service的每个子类，例如BoxService应该只能保存Box个对象。

由于这样的事实：C++不支持方法参数的协方差，我不能简单地声明的保存方法BoxService.h，如：

void save(Box box); 

我的问题是，有没有什么最佳设计模式或最佳实践为问题？或者，如果到达的Model对象是Box类型，并且在其他情况下抛出异常，我应该检查BoxService.cpp中的保存函数的实现吗？

Model.h

class Model { 
private: 
    int id; 
}; 

Box.h

class Box : public Model { 
private: 
    int size; 
}; 

Service.h

class Service { 
public: 
    virtual void save(Model model); 
}; 

BoxSe rvice.h

class BoxService : public Service { 
public: 
    void save(Model box); 
}; 

BoxService.cpp

void BoxService::save(Model box) { 
    // TODO: save box and make sure that box is of type 'Box' and not any other subtype of 'Model' 
} 

Answer 1

所以，你喜欢你的声音要随机型集团化运作实现。我将解释更多的面向对象方法。

独立Service从实现，但我们要摆脱讨厌的参数：

class Service { ... }; 
class ServiceImpl { 
    virtual ~ServiceImpl() {} 
    void save() const = 0; 
    void remove() const = 0; 
}; 

每个实施将是轻量级和支持业务，但将采取参数构造函数：

class BoxService : public ServiceImpl { 
    Box _b; 

public: 
    BoxService(Box b) : _b(b) {} 

    void save() const { ... } 
    void remove() const { ... } 
}; 

现在我们有一个抽象工厂来创建实现，因为我们需要他们：

class ServiceImplFactory { 
public: 
    std::unique_ptr<ServiceImpl> create(Model m) const { 
     if (auto b = dynamic_cast<Box*>(m)) { 
      return std::make_unique<BoxService>(*b); 
     } else if (auto x = dynamic_cast<X*>(m)) { 
      return std::make_unique<XService>(*x); 
     } else { 
      assert(!"Not all Models covered by Service implementations"); 
     } 
    } 
}; 

现在Service：

class Service { 
    ServiceImplFactory _implFactory; 

public: 
    void save(Model m) const { 
     return _implFactory.create(m)->save(); 
    } 

    void remove(Model m) const { 
     return _implFactory.create(m)->remove(); 
    } 
}; 

进一步的步骤：

• 工程师的溶液，给出了一个编译时间错误，而不是断言的。
• 允许添加更多的模型类型和更多的操作，而无需更改（很多）现有的代码。这应该等同于表达式问题。请注意，按照模型类型分组操作的这种方法需要进行更广泛的添加新操作的更改，而不是添加新的模型类型。相反，对于使用访问者和按操作对模型类型进行分组，这是正确的。有表达式问题的解决方案，例如object algebras，但它们可能有点模糊。

Answer 2

这里有可能是一个更实用的方法：

配对其实现每个模型类型：

template<typename T, typename ExtraType> 
struct WithType { 
    T value; 
    using extra_type = ExtraType; 

    WithType(T value) : value(value) {} 
}; 

定义Model作为一个变体，而不是继承层次：

using Model = std::variant<WithType<Box, BoxService>, WithType<X, XService>>; 

现在访问变种：

class Service { 
public: 
    void save(Model m) const { 
     visit([](auto withService) { 
      typename decltype(withService)::extra_type service; 
      service.save(withService.value); 
     }, m); 
    } 

    void remove(Model m) const { 
     visit([](auto withService) { 
      typename decltype(withService)::extra_type service; 
      service.remove(withService.value); 
     }, m); 
    } 
};