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

Question

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

我考虑过的一些事情：

1. 使用枚举
   • 优点：
     1. 我知道怎么做
   • 缺点
     1. 我必须在添加新类时更新枚举
     2. 很难迭代
2. 在接口中使用某种static 列表对象，并从实现类的定义文件中添加一个新元素
   • 优点：
     1. 不必更改旧代码
   • 缺点：
     1. 甚至不确定这是否可能
     2. 不确定要存储什么样的信息，以便工厂方法可以选择正确的构造函数（可能是字符串和返回指向接口对象的指针的函数指针之间的映射）

我猜这是一个更有经验的程序员可能以前（并且经常）遇到的问题（或类似于问题），并且对于此类问题可能有一个通用的解决方案，这几乎肯定会更好比我能想到的任何东西都要好。那么，我该怎么做呢？

（P.S. 我搜索过，但我发现的只是这个，而且不一样：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

我隐约记得很多年前做过类似的事情。您的选择（2）几乎就是我所做的。在那种情况下，它是std::string 到std::typeinfo 的std::map。在每个 .cpp 文件中，我注册了这样的类：

static dummy = registerClass (typeid (MyNewClass));

registerClass 接受type_info 对象并简单地返回true。您必须初始化一个变量以确保在启动期间调用registerClass。简单地在全局命名空间中调用registerClass 是一个错误。并且将dummy 设为静态允许您跨编译单元重用名称而不会发生名称冲突。

Answer 3

我参考这篇文章来实现一个类似于 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

Answer 4

如果您在 Windows 上并使用 C++/CLI，这将变得相当容易。 .NET 框架通过反射提供了这种能力，它在托管代码中工作得非常干净。

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

Answer 5

您可以考虑使用对象计数器。这样，您无需更改分配的每个位置，而只需更改实现定义。它是工厂解决方案的替代方案。考虑利弊。

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

这样你只需要添加你的具体类实现：

class X; // your interface

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

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

编辑：

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

我的 2 美分

Answer 6

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