template<class THANDLE=int,unsigned int INVALID_HANDLE=0> class Handled{
  protected:
    THANDLE Handle;

    Handled(){
      Handle=INVALID_HANDLE;
    }

    ~Handled(){
      if (handleAllocated())
        deleteHandle();
    }

    void handleNeeded(){
      if (!handleAllocated())
        createHandle();
    };

    virtual void createHandle()=0;
    virtual void deleteHandle()=0;
  public:
    int handleAllocated(){
      return Handle!=INVALID_HANDLE;
    };

    THANDLE getHandle(){
      handleNeeded();
      return Handle;
    };

    void recreateHandle(){
      if (handleAllocated()){
        deleteHandle();
        Handle=INVALID_HANDLE;
        handleNeeded();
      }
    };
};

class Window: public Handled<int,0>{
  protected:
    char *Name;
    Window *Parent;
    int X,Y,Width,Height;

    void call(){
      glutSetWindow(getHandle());
    };

    void createHandle();
    void deleteHandle();
  public:
    Window(char *name,int x=100,int y=100,int width=320,int height=240):Name(name),Parent(NULL),X(x),Y(y),Width(width),Height(height){
      handleNeeded();
    };

    Window(char *name,Window *parent,int x=80,int y=60,int width=160,int height=120):Name(NULL),Parent(parent),X(x),Y(y),Width(width),Height(height){
      handleNeeded();
    };
}

void Window::createHandle(){
  /* Code qui crée une fenêtre avec GLUT et stocke l'index retourné dans Handle */
};

void Window::deleteHandle(){
  /* Code qui crée une fenêtre avec GLUT et stocke l'index retourné dans Handle */
};

Donc voilà j'ai une classe de base qui sert à dériver des sous-classes encapsulant des objets systèmes auxquels on accède via une série d'API et un "Handle" qui est typiquement un entier. Le template avec THANDLE et INVALID_HANDLE sert à faire la distinction entre les objets systèmes qui sont liés à un entier signé (fenêtres GLUT par exemple) et ceux qui sont liés à un entier non signé (identifiants de texture OpenGl par exemple).

Les appels aux API servant à allouer/libérer les Handle systèmes en question sont définis dans la classes descendante en surchargeant les méthodes virtuelles pures createHandle et deleteHandle. Tout se passe bien dans les constructeurs qui appellent (directement ou indirectement) createHandle, la méthode descendante est appelée et mon objet système est bien créé.

Mais, et ça je n'arrive pas à l'expliquer, lorsqu'une instance de la classe descendante est détruite, ce n'est pas le cas : c'est la méthode de base deleteHandle qui est appelée... générant bien évidemment une exception "pure virtual function call". J'ai naïvement essayé de rendre le destructeur virtuel, voire de passer par un pointeur sur l'instance en espérant court-circuiter le typage à la compilation (car c'est de ça qu'il s'agit je suppose) rien n'y fait.

Est-ce une spécification du C++ (toute la doc que j'ai lue jusque-là n'en faisait pas mention en tout cas)? Est-ce que ça vient de ce que ma classe est une template?

Merci d'avance de votre aide.

Window * pWindow = new Window();
Handled * pHandled = pWindow;
delete pHandled;

Si ton destructeur n'est pas virtuel, c'est le destructeur de pHandled qui sera appelé dans ce cas.

delete pWindow <= ici le destructeur de Window.

Donc ca coute rien de toujours mettre le destructeur virtuel:
virtual ~Handled();

Mais ya aucun pb. Sauf que toi il semble que tu l'ais mis virtuel pure, ce qui n'a évidemment aucun sens ici, mais c'est faisable dans certain cas.