我该如何跟踪（枚举）实现接口的所有类

Question

我有一种情况，我有一个接口来定义某个类的行为，以便填充程序中的某个角色，但此时我不是100％确定我会写多少课来填补这个角色。然而，与此同时，我知道我希望用户能够从GUI组合/列表框中选择实现他们想要用来填充某个角色的接口的具体类。我希望GUI能够枚举所有可用的类，但是我希望在我决定实现新类时填充该角色（可能从现在开始几个月）不必返回并更改旧代码

有些事情我已经考虑：使用枚举

• 优点
  1. ：
     1. 我知道如何做到这一点
  个
  2. 缺点
     1. 我将有更新的时候我添加一个新类
     2. 丑陋使用某种static列表对象的接口，通过

迭代更新枚举，并从执行类的定义文件中添加新元素

• 优点：
  1. 不会必须改变旧的代码
• 缺点：
  1. 甚至不知道这是可能的
  2. 不知道存储什么样的信息，以便工厂方法可以选择正确的构造函数（可能是字符串和函数指针之间的映射，它返回指向接口对象的指针）

我猜这是一个问题（或类似于一个问题），更有经验的程序员可能会遇到过（经常），并可能有一个共同的解决方案，这种问题，这是几乎肯定比我能够提出的任何东西都要好。那么，我该怎么做呢？

（PS我搜索，但所有我发现了这一点，它是不一样的：How do I enumerate all items that implement a generic interface?看样子他已经知道怎么解决，我想弄清楚这个问题。）

编辑：将标题重命名为“我怎样才能跟踪...”，而不是“我怎样枚举......”，因为原来的问题听起来像我更感兴趣的是检查运行时环境，因为我真的感兴趣的是编译时簿记。

Answer 1

创建一个单例，您可以在其中使用指向创建者函数的指针注册您的类。 在具体类的cpp文件中注册每个类。
事情是这样的：

class Interface; 
typedef boost::function<Interface*()> Creator; 

class InterfaceRegistration 
{ 
    typedef map<string, Creator> CreatorMap; 
public: 
    InterfaceRegistration& instance() { 
     static InterfaceRegistration interfaceRegistration; 
     return interfaceRegistration; 
    } 

    bool registerInterface(const string& name, Creator creator) 
    { 
     return (m_interfaces[name] = creator); 
    } 

    list<string> names() const 
    { 
     list<string> nameList; 
     transform(
      m_interfaces.begin(), m_interfaces.end(), 
      back_inserter(nameList) 
      select1st<CreatorMap>::value_type>()); 
    } 

    Interface* create(cosnt string& name) const 
    { 
     const CreatorMap::const_iterator it 
      = m_interfaces.find(name); 
     if(it!=m_interfaces.end() && (*it)) 
     { 
      return (*it)(); 
     } 
     // throw exception ... 
     return 0; 
    } 

private: 
    CreatorMap m_interfaces; 
}; 


// in your concrete classes cpp files 
namespace { 
bool registerClassX = InterfaceRegistration::instance("ClassX", boost::lambda::new_ptr<ClassX>()); 
} 

ClassX::ClassX() : Interface() 
{ 
    //.... 
} 

// in your concrete class Y cpp files 
namespace { 
bool registerClassY = InterfaceRegistration::instance("ClassY", boost::lambda::new_ptr<ClassY>()); 
} 

ClassY::ClassY() : Interface() 
{ 
    //.... 
} 

Answer 2

如果您使用的是Windows，并且使用C++/CLI，则这变得相当容易。这个。.NET框架通过反射来提供这种功能，并且它在托管代码中非常干净地工作。

在原生C++中，这有点棘手，因为没有简单的方法来查询库或应用程序的运行时信息。有很多frameworks that provide this（只需查找IoC，DI或插件框架），但最简单的做法是使用某种形式的配置，工厂方法可以使用这些配置来注册自己，并返回特定基础的实现类。你只需要实现加载一个DLL，并注册工厂方法 - 一旦你有了，这很容易。

Answer 3

无法在（本机）C++中查询类的子类。 你如何创建实例？考虑使用工厂方法，允许您迭代您正在使用的所有子类。当你像这样创建一个实例时，以后不可能忘记添加一个新的子类。

Answer 4

我依稀记得做了类似于很多年前的事情。你的选择（2）几乎是我所做的。在那种情况下，它是std::string至std::typeinfo的std::map。在每一个，.cpp文件我注册的类是这样的：

static dummy = registerClass (typeid (MyNewClass)); 

registerClass需要type_info对象，只是返回true。您必须初始化变量以确保在启动期间调用registerClass。在全局名称空间中仅调用registerClass是一个错误。并且使dummy静态允许您在没有名称冲突的编译单元中重复使用该名称。

Answer 5

有些事情，你可以考虑的是一个对象计数器。这样你就不需要改变你分配的每个地方，而只需要实现定义。这是工厂解决方案的替代方案。考虑利弊。

一个优雅的方法是使用CRTP : Curiously recurring template pattern。 主要的例子是这样的计数器:)

这种方式，你只需要在你的具体类实现增加：

class X; // your interface 

class MyConcreteX : public counter<X> 
{ 
    // whatever 
}; 

当然，这是不适用的，如果你使用你没有掌握外部实现。

编辑：

要处理，你需要有一个计数器，只计算第一个实例确切的问题。

我的2美分

Answer 6

我提到这篇文章来实现类似TIMW的回答中描述的一个自行注册类工厂，但它使用模板的工厂代理类来处理对象的好的技巧注册。非常值得一看:)用C

自行注册的对象++ - >http://www.ddj.com/184410633

编辑

这里的测试程序我做（整理了一点点）：

object_factory。^h

#include <string> 
#include <vector> 
// Forward declare the base object class 
class Object; 
// Interface that the factory uses to communicate with the object proxies 
class IObjectProxy { 
public: 
    virtual Object* CreateObject() = 0; 
    virtual std::string GetObjectInfo() = 0; 
}; 
// Object factory, retrieves object info from the global proxy objects 
class ObjectFactory { 
public: 
    static ObjectFactory& Instance() { 
     static ObjectFactory instance; 
     return instance; 
    } 
    // proxies add themselves to the factory here 
    void AddObject(IObjectProxy* object) { 
     objects_.push_back(object); 
    } 
    size_t NumberOfObjects() { 
     return objects_.size(); 
    } 
    Object* CreateObject(size_t index) { 
     return objects_[index]->CreateObject(); 
    } 
    std::string GetObjectInfo(size_t index) { 
     return objects_[index]->GetObjectInfo(); 
    } 

private: 
    std::vector<IObjectProxy*> objects_; 
}; 

// This is the factory proxy template class 
template<typename T> 
class ObjectProxy : public IObjectProxy { 
public: 
    ObjectProxy() { 
     ObjectFactory::Instance().AddObject(this); 
    }   
    Object* CreateObject() { 
     return new T; 
    } 
    virtual std::string GetObjectInfo() { 
     return T::TalkToMe(); 
    };  
}; 

objects.h

#include <iostream> 
#include "object_factory.h" 
// Base object class 
class Object { 
public: 
    virtual ~Object() {} 
}; 
class ClassA : public Object { 
public: 
    ClassA() { std::cout << "ClassA Constructor" << std::endl; } 
    ~ClassA() { std::cout << "ClassA Destructor" << std::endl; } 
    static std::string TalkToMe() { return "This is ClassA"; } 
}; 
class ClassB : public Object { 
public: 
    ClassB() { std::cout << "ClassB Constructor" << std::endl; } 
    ~ClassB() { std::cout << "ClassB Destructor" << std::endl; } 
    static std::string TalkToMe() { return "This is ClassB"; } 
}; 

objects.cpp

#include "objects.h" 
// Objects get registered here 
ObjectProxy<ClassA> gClassAProxy; 
ObjectProxy<ClassB> gClassBProxy; 

的main.cpp

#include "objects.h" 
int main (int argc, char * const argv[]) { 
    ObjectFactory& factory = ObjectFactory::Instance(); 
    for (int i = 0; i < factory.NumberOfObjects(); ++i) { 
     std::cout << factory.GetObjectInfo(i) << std::endl; 
     Object* object = factory.CreateObject(i); 
     delete object; 
    } 
    return 0; 
} 

输出：

This is ClassA 
ClassA Constructor 
ClassA Destructor 
This is ClassB 
ClassB Constructor 
ClassB Destructor