在 C++ 中，如何避免使用泛型类型映射显式向下转换？

Question

这有点做作，但假设我有一个这样的类接口：

class IResource;
class IResourceContainer
{
 public:
    virtual ~IResourceContainer() {}
    virtual void AddResource(const std::string& rStrName, 
                             std::auto_ptr<IResource> apResource)=0;
    virtual IResource& GetResource(const std::string& rStrName)=0; 
};

我有一个此类的实现，其中包含字符串到 IResource 类型的映射。如果我要像这样添加自己的资源：

container.AddResource("foo", std:auto_ptr<IResource>( new CFooResource);

然后再检索资源引用

CFooResource& fooResource = container.GetResource(); // error

这不会编译，因为我需要将 IResource 向下转换为 CFooResource。我曾考虑通过让 GetResource 采用模板参数来隐藏这一点，该参数在内部向下转换类型，但显然，模板和纯接口不会出错。我目前的替代方法是将转换隐藏在调用 boost::polymorphic_downcast 的 CastResource 函数中，但我仍然对客户端需要转换资源的想法感到不快。

例如：

CFooResource& fooResource = CastResource<CFooResource&>(container.GetResource());

所以我想我的问题是：有没有更好的方法来保存指向不需要用户明确向下转换的泛型类型的指针？我觉得有一种模板化的方式可以做到这一点，但我没有看到。另外，我制作了这个界面，以便客户可以在需要时轻松地在测试中模拟它。

谢谢。

Answer 1

有没有更好的方法来保存指向不需要用户明确向下转换的泛型类型的指针？

没有。
要么您使用的是经典的 OO，也就是 运行时多态性。然后你就被基类接口卡住了，或者你不得不作弊和贬低。或者你使用模板，也就是编译时多态。然后，您在编译时被绑定到单一资源类型。

有一些方法可以稍微模糊两者之间的边界（例如boost::any），但基本上这些是你必须决定的两者。

Answer 2

也许你正试图解决错误的问题。

如果只在IResource 中实现适当的抽象接口而不用担心向下转换呢？如果接口是在父类中实现的，你只需要对IResource进行适当的虚调用，而不用担心它具体是哪种类型并进行相应的向下转换。

Answer 3

class ResourceWrapper {
private:
    IResource *resource;

public:
    ResourceWrapper() { }
    ResourceWrapper(IResource *resource) : resource(resource) { }
    ResourceWrapper(ResourceWrapper wrapper) : resource(wrapper.resource) { }

    template <class T>
    T &As()
    {
        if (resource == NULL) return NULL;
        T *ret = dynamic_cast<T*>(resource);
        if (ret == NULL) throw Exception("wrong resource type");
        return ret;
    }
};

class IResourceContainer
{
public:
    virtual ~IResourceContainer() {}
    virtual void AddResource(const std::string& rStrName, 
    std::auto_ptr<IResource> apResource)=0;
    virtual ResourceWrapper GetResource(const std::string& rStrName)=0; 
};

CFooResource& fooResource = container.GetResource("name").As<CFooResource>();

或

class ResourceWrapper {
private:
    IResource *resource;

public:
    ResourceWrapper() { }
    ResourceWrapper(IResource *resource) : resource(resource) { }
    ResourceWrapper(ResourceWrapper wrapper) : resource(wrapper.resource) { }

    template <class T>
    void Get(T **ret)
    {
        *ret = dynamic_cast<T*>(resource);
        /* optionally throw exception when dynamic_cast fails */
    }
};

class IResourceContainer
{
public:
    virtual ~IResourceContainer() {}
    virtual void AddResource(const std::string& rStrName, 
    std::auto_ptr<IResource> apResource)=0;
    virtual ResourceWrapper Resource(const std::string& rStrName)=0; 
};

CFooResource *fooResource;
container.Resource("name").Get(&fooResource);

Answer 4

如果资源容器的目的是只保存指针，那么你可以把它做成一个模板类

Answer 5

如果不同资源类型的数量较少且相对固定，您可以为资源容器创建额外的方法，例如IStringResource& GetStringResource(string name)。在内部，您可以将每种资源类型存储在具有更具体资源类型的不同映射中。这为您提供了有关向下转换的完整编译时安全性。

我想不出另一种方法来避免演员表。但是，由于您要返回对资源的引用，因此您仍然必须处理找不到资源的情况。这必须通过抛出异常来处理，因为您不能返回 0。如果您仍然要抛出异常，您可以通过创建模板方法让您的生活更轻松。

T& GetResource<T>(string name) 
{
    IResource* res = ...fetch resource...
    T* tres = dynamic_cast<T*>(res);
    if (tres == 0)
    {
         throw ResourceNotFoundException();
    }
    return *tres;
}

我的模板语法有点生疏，但我希望这能说明问题。