c++ - 模板使用不当？

Question

我知道模板有点被指责为二进制膨胀，我也知道模板只是一种模式。我不太了解其中的具体细节。

很多时候我看到类似下面的代码，它返回一个基类指针。

class GameObject
{
public:
    Component* getComponent(std::string key);
};

static_cast<Comp>(obj.getComponent("Comp"));

而不是使方法成为模板方法。

class GameObject
{
public:
    template<typename T>
    T* getComponent(std::string key);
};

obj.getComponent<Comp>("Comp");

这是风格问题还是与模板相关的性能损失？

Answer 1

事实上，该方法采用的“键”看起来确实是一种类型(要返回的组件的类型)，这对我来说表明该类型直到运行时才真正为人所知。如果是这种情况，那么像模板这样的编译时机制将无法使用。

唯一的选择是返回一个基类指针。通常，当使用此模式时，只会针对基类调用虚方法——因此派生类的实际类型并不重要(因此不需要 static_cast 或 dynamic_cast)。

编辑:

正如 PhilCK 在评论中指出的那样，类型在编译时实际上是已知的。如果是这种情况，那么动态类型查找从来就不是真正需要的，并且可以使用简单的工厂方法:

class GameObject {
    A getComponentA();
    B getComponentB();
    C getComponentC();
    // etc.
}

// which is more or less identical to:

class ComponentFactory {
    public:
    virtual Component* create() = 0;
};
class GameObject {
    std::map<std::string,ComponentFactory> m;
    public:
    GameObject() {
        // presumably a private map has to be populated with string -> factory methods here
    }

    template<class T>
    T* getComponent(const std::string& s) { 
        // either the static_cast is needed here, or an alternate (messier)
        // implementation of getComponent is needed.
        // it's still possible for the wrong type to be passed (by mistake)
        // and the compiler won't catch it (with static_cast). Since this could lead
        // to heap corruption the only safe way with this type of 
        // implementation is dynamic_cast.
        return static_cast<T>(m[s].create());
    }
};

// this doesn't even compile:
// return types:
class GameObject {
    template <class T>
    T* getComponent(const std::string& s) {
        if (s == "A") return new A();
        else if (s == "B") return new B();
        // etc..
        else throw runtime_error("bad type");
    }
}

所以在我看来有两种选择。

1) 使用简单的工厂方法，在这种情况下根本不需要模板。2) 将 map -> 工厂方法实现与 dynamic_cast 一起使用(这似乎违背了使用动态类型创建的目的)，如果不需要动态类型，实际上会不必要地复杂