Re: Pure virtual functions in Template class?

Sorry, for the sake of brevity I excluded most of the code. Here is
an accurate representation:

in Singleton.h:

#ifndef __SINGLETON_H
#define __SINGLETON_H

template <typename T>
class Singleton
{
    public:
        static T& getInstance(void)
        {
            if(m_pInstance == NULL)
                m_pInstance = new T;

            return *m_pInstance;
        }

    protected:
        Singleton() { }
        Singleton(const Singleton&);
        virtual ~Singleton() { }
        Singleton& operator=(const Singleton&);

    private:
        static T* m_pInstance;

};

template <typename T>
T* Singleton<T>::m_pInstance = NULL;

#endif

In Registry.h

#ifndef __REGISTRY_H
#define __REGISTRY_H

#include <map>
#include <string>
#include <algorithm>

#include <Design/Subject.h>
#include <Utility/Globals.h>
#include <Design/Singleton.h>

struct delete_ptr
{
    template <typename T>
    void operator() (const T& obj) const
    {
        delete obj.second;
    }
};

template <typename ResourceType>
class Registry
    : public Subject
{
    public:
        typedef std::string resource_type;

        ResourceType* create(std::string);
        void clear();
        bool empty() { return m_list.empty(); }

        virtual resource_type getType() = 0;

    protected:
        Registry() { }
        virtual ~Registry() { clear(); }
        Registry(const Registry&);
        Registry& operator=(const Registry&);

        virtual ResourceType* loadResource(std::string) = 0;

        typedef std::map<resource_type, ResourceType*> registry_list;
        registry_list m_list;

};

template <typename ResourceType>
ResourceType* Registry<ResourceType>::create(std::string name)
{
    return NULL;
}

template <typename ResourceType>
void Registry<ResourceType>::clear()
{
    notifyAll();
    for_each(m_list.begin(), m_list.end(), delete_ptr());
    m_list.clear();
}

#endif

and finally, FontRegistry.h:

#ifndef __FONTREGISTRY_H
#define __FONTREGISTRY_H

#include <string>

#include <FTGLPixmapFont.h>

#include <Resources/Registry.h>

#define FONT_TYPE ".ttf"

class FontRegistry
    : public Registry<FTFont>
    , public Singleton<FontRegistry>
{
    public:
        ~FontRegistry();

        resource_type getType() { return FONT_TYPE; }

    protected:
        FTFont* loadResource(std::string) { return NULL; }

    private:
        FontRegistry() { }
        FontRegistry(const FontRegistry&);
        FontRegistry operator=(const FontRegistry&);

        typedef FTGLPixmapFont FontType;

    friend class Singleton<FontRegistry>;

};

#endif

The font registry is used like so:

FTFont* ftgl_font = FontRegistry::getInstance().create(font);

Compilation in Code::Blocks with the MinGW compiler gives these
errors:

C:\MinGW\bin\..\lib\gcc\mingw32\3.4.2\..\..\..\..\include\c++
\3.4.2\backward\backward_warning.h:32: warning: #warning This file
includes at least one deprecated or antiquated header. Please consider
using one of the 32 headers found in section 17.4.1.2 of the C++
standard. Examples include substituting the <X> header for the <X.h>
header for C++ includes, or <iostream> instead of the deprecated
header <iostream.h>. To disable this warning use -Wno-deprecated.
...\..\Framework_01\src\System\Console.cc:44: warning: unused variable
'width'
C:\mingw\include\c++\3.4.2\bits\stl_list.h:: undefined reference to
`vtable for FontRegistry'
:C:\mingw\include\c++\3.4.2\bits\stl_list.h:: undefined reference to
`vtable for FontRegistry'
:: === Build finished: 2 errors, 2 warnings ===