C ++继承：调用模板的子类函数

Question

I have a templated class, and a subclass of the templated class in order to implement a function differently. Since I want to keep the flexibility of having multiple subclasses, I don't directly store the subclass itself. In Java, something like what I'm trying to do would work, but apparently it doesn't in C++.

template<class Res> class Loader {
public:
    Res* loadFromFile(std::string filePath);
};


template<class Res> inline Res* Loader<Res>::loadFromFile(std::string filePath){return NULL;}

Subclass:

class TextureLoader : public Loader<sf::Texture> {
public:
    sf::Texture* loadFromFile(std::string path);
};

inline sf::Texture* TextureLoader::loadFromFile(std::string path){
    sf::Texture* texture = new sf::Texture();
    texture->loadFromFile(path);
    return texture;
}

Somewhere in another class I store an instance of a Loader:

Loader<Res> * loader;

My problem is, that even if I assign a TextureLoader instance to that loader variable, only the superclass-function is called, but not the actually implemented subclass function. How can I achieve to call the subclas function while keeping the flexibility of having multiple loaders?

Answer 1

You may not want inheritance - it looks like you may want specialization instead:

template<>
sf::Texture* Loader<sf::Texture>::loadFromFile(std::string path) {...}

Now just use Loader<sf::Texture> where before you planned to use TextureLoader . Or, typedef the latter to the former.

Answer 2

In order for dynamic dispatch to take place you need to declare the member function virtual in the base class. You will also want to declare the destructor as virtual to ensure that derived classes are properly cleaned up when they are deleted through a base class type.

template<class Res> class Loader {
public:
    virtual ~Loader() [}
    virtual Res* loadFromFile(std::string filePath);
};

Answer 3

Your function is never marked as virtual. That said, you should really make it abstract, because it has no use without overwriting it:

template<class T> class Loader 
{
public:
   virtual T* LoadFromFile(const std::string& filePath) = 0;
   virtual ~Loader() {}
};

class TextureLoader : public Loader<sf::Texture>
{
public:
   virtual sf::Texture* LoadFromFile(const std::string& filePath);
   {
     sf::Texture* texture = new sf::Texture();
     texture->loadFromFile(path);
     return texture;
   }
};