Est-ce que je m'y prends mal ?

Bonjour, encore besoin d'un coup de main : je vais de crash en crash sans
arriver à déterminer ce qui ne va pas. Une chose est sure, l'outil que
j'utilise pour vérifier les erreurs d'allocation/deallocation me signale
une erreur dans une de mes méthodes sans que je comprenne ce que je peux
bien faire de travers.

Voici une version réduite du code, je voudrais que vous me disiez si ce
que je fais est valide ou pas (je parle du principe, je poste donc une
version simplifiée du code d'origine).

------------------------------------------------------------------

J'ai 3 classes :

class Stuff2D
{
public:
Stuff2D(void);
virtual ~Stuff2D(void);
}

class Sprite2D : public Stuff2D
{
public:

Sprite2D(void);
virtual ~Sprite2D(void);
}

class Sprite2DAnimated : public Stuff2D
{
public:
Sprite2DAnimated(void);
virtual ~Sprite2DAnimated(void);
}

------------------------------------------------------------------

Et j'ai aussi une classe qui sert de "loader" :

static class StuffLoader
{
public:
StuffLoader(void);
~StuffLoader(void);

Stuff2D* loadStuff(std::string fileName);

private:
typedef std::map<std::string,Stuff2D*> stuffMap;
typedef stuffMap::iterator stuffIterator;

stuffMap m_objects;

} stuffLoader;

------------------------------------------------------------------

Maintenant la méthode qui pose problème :

Stuff2D* StuffLoader::loadStuff(std::string fileName)
{
stuffIterator it;

it=m_objects.find(fileName);
if(it==m_objects.end()) // stuff n'existe pas
{
if(fileExists(fileName + ".ani"))
{
Sprite2DAnimated* new_stuff = new Sprite2DAnimated();
new_stuff->load(fileName);
m_objects.insert(std::make_pair(fileName,new_stuff));
return new_stuff;
}
else if(fileExists(fileName + ".bmp"))
{
Sprite2D* new_stuff = new Sprite2D();
new_stuff->load(fileName + ".bmp");
m_objects.insert(std::make_pair(fileName,new_stuff));
return new_stuff;
}
else
return NULL;
}
else
// stuff existe
return (*it).second; // Retourne un pointeur vers l'instance;
}

Qui est appellée de la manière suivante (dans main.cpp par exemple)

Stuff2D* sp1;
sp1 = stuffLoader.loadStuff("spr1");

------------------------------------------------------------------

Une erreur est détectée sur la ligne Sprite2D* new_stuff = new Sprite2D
();

L'erreur est "allocation overrun", ce que je traduis par débordement
d'allocation, je suppose que le heap de l'application est endommagé à ce
moment précis (c'est une simple supposition).

Toujours est-il qu'à la sortie de l'application, quand je dois détruire
les instances allouées dynamiquement le heap est réellement endommagé.

Du coup, je me demande s'il est bien possible d'avoir :
- dans main un objet déclaré comme Stuff2D*
et
- dans loadStuff retourner en réalité soit un Sprite2D*, soit un
Sprite2DAnimated*

Y-a-t-il quelque chose d'erroné dans ma manière de procéder ??

Merci