在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接受一个模板参数来降低内部类型，但是很明显，模板和纯粹的接口不是jive。我目前的选择是隐藏在调用boost :: polymorphic_downcast的CastResource函数中的投射，但我仍然不满意客户需要投射资源的想法。

例如：

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

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

谢谢。

Answer 1

是否有更好的方法来保持泛型类型的指针，而不需要用户明确的向下转换？

号
无论您使用传统的面向对象，又名运行时多态性。然后你被困在基类接口中，或者你必须作弊和向下转换。或者你使用模板，也叫做编译时多态性。然后，您在编译时绑定到单个资源类型。

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

Answer 2

如果资源容器的目的是只持有指针，那么你可以使它成为一个模板类

Answer 3

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

只要在IResource内部实施适当的抽象界面，而根本不担心向下转换呢？如果该接口是在父类中实现的，则只需在IResource上进行适当的虚拟呼叫，而不用担心具体是哪种类型，并进行相应的向下转换。

Answer 4

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 5

如果不同资源类型的数量低，相对固定的，你可以只创建额外的方法到资源的容器，例如IStringResource& GetStringResource(string name)。在内部，您可以使用更具体的资源类型将每种资源类型存储在不同的映射中。这为您提供了有关do​​wncast的完整编译时安全。

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

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

我对我的模板语法有点生疏，但我希望这可以得到重点。