C++优雅模板注入(inject)接口(interface)

Question

我需要一些技巧来实现不支持的 C++:我需要混合动态和静态多态性(虚拟和模板)。我需要什么(一些原理图代码):

class IManager
{
public:
    template<class T>
    void Set();
    template<class T>
    T *Get();

protected:
    IManager *_parent;
};

class Manager1: public IManager{};
class Manager2: public IManager{};

// the main goal is a semantic:
IManager manager = Manager1;
// IManager manager = Manager2;
manager.Set<MyClass>();
MyClass *myClass = manager.Get<MyClass>();

这有点像服务定位器。但它有一些差异，我需要这样的接口(interface)声明。我已经有这样的实现，但是没有接口(interface)(它只能通过构造函数中的选项配置，我想分开每个接口(interface)的实现)

更新:现在我有2个实现:1.我使用接口(interface)，但它的方法是通过参数覆盖模板参数的所有状态。而且我还有静态函数助手，它转换模板参数并将它们作为参数传递给接口(interface)

class Manager: IManager{};
Manager manager;
Helper::Set<T>( manager );
Helper::Get<T>( manager );

1. 我不使用接口(interface)，而是在一个实例中注入(inject)所有不同的实现，并通过构造函数参数对其进行配置。这两种解决方案都很丑陋。

   类(class)经理{民众: 经理(选项)；};

Answer 1

这可以通过访问者设计模式来实现。

Visitor 将新功能注入(inject)到类的层次结构中。这不需要是虚拟的，可以毫无问题地表示为函数模板。

访问者的常见缺点(循环依赖)和通常的修复/解决方法(非循环动态访问者技术)也是如此。

这是一个(常规的，循环的)实现示例，快速组合在一起。

#include <iostream>
#include <typeinfo>

class Manager1;
class Manager2;

class Visitor
{
  public:
  virtual void visit (Manager1*) = 0;
  virtual void visit (Manager2*) = 0;
};

class IManager
{
  public:
    template<class T> void Set(T* t);
    template<class T> T *Get();

    virtual void accept(Visitor* v) = 0;
};

class Manager1: public IManager
{
  public:
    template<class T> void Set(T*) 
    { std::cout << "Manager1::Set " << typeid(T).name() << std::endl; }
    template<class T> T *Get() 
    { std::cout << "Manager1::Get " << typeid(T).name() << std::endl; return 0; }
    virtual void accept(Visitor* v) 
    { v->visit(this); }
};

class Manager2: public IManager
{
  public:
    template<class T> void Set(T* t) 
    { std::cout << "Manager2::Set " << typeid(T).name() << std::endl; }
    template<class T> T *Get()
    { std::cout << "Manager2::Get " << typeid(T).name() << std::endl; return 0; }
    virtual void accept(Visitor* v) 
    { v->visit(this); }
};


template <class T>
class GetVisitor : public Visitor
{
  public:
    T* GetFunc(IManager* m) { m->accept(this); return t; }
    void visit(Manager1* m) { t = m->Get<T>(); }
    void visit(Manager2* m) { t = m->Get<T>(); }
  private:
    T* t;
};

template <class T>
class SetVisitor : public Visitor
{
  public:
    void SetFunc(IManager* m, T* tt) { t = tt; m->accept(this); }
    void visit(Manager1* m) { m->Set(t); }
    void visit(Manager2* m) { m->Set(t); }
  private:
    T* t;
};

template<class T> void IManager::Set(T* t)
{ SetVisitor<T> v; v.SetFunc(this, t); }
template<class T> T *IManager::Get()
{ GetVisitor<T> v; return v.GetFunc(this); }

class Foo {};

int main ()
{
  IManager* mgr1 = new Manager1;
  IManager* mgr2 = new Manager2;

  int a = 5;
  const char* b = "abc";
  double c = 1.0;
  Foo d;

  mgr1->Set(&a);
  mgr1->Set(&b);
  mgr1->Set(&c);
  mgr1->Set(&d);
  mgr1->Get<Foo>();

  mgr2->Set(&a);
  mgr2->Set(&b);
  mgr2->Set(&c);
  mgr2->Set(&d);
  mgr2->Get<Foo>();

}

可以用一些dynamic_cast打破循环，但是Set和Get的每个用户仍然依赖于所有 Manager 类。这就是模板在 C++ 中的工作方式。如果这是 Not Acceptable ，那么模板可能不是这项工作的正确工具。