Je fais des choses géniales avec le placement nouveau, et les choses échouent. Solutions de contournement?

Question

J'ai une très grande classe étalée qui est essentiellement une liste chaînée tridimensionnelle très artificielle. Je veux être capable de le «compiler», ce qui signifie que je veux terminer la liste, de sorte que seuls les accès en lecture puissent être faits, puis déplacer tous les éléments dans des espaces mémoire contigus. Ma solution brute est la suivante:

#include <new> 
... 
MyListNode* pool = new MyListNode[length]; 
new(&pool[position]) MyListNode(); 

Le problème est que j'ai essentiellement deux classes, l'une attribuée avec nouvelle et l'autre alloué avec cette méthode ici, et quand je tente de supprimer l'un des objets attribués par la La méthode ci-dessus, glibc tue le programme à cause d'un pointeur invalide. La solution naturelle est de créer deux classes, et d'utiliser simplement le polymorphisme d'exécution pour fournir une interface mais deux implémentation, etc. Est-il possible que le standard de mémoire en C++ permette ce type de pokery jiggery?

Answer 1

Appellez-vous delete sur l'un des objets de votre tableau? Ou appelez-vous manuellement le destructeur pour refléter le placement nouveau?

Étant donné que vous avez un appel au non-placement nouveau, vous ne devriez avoir qu'un seul appel à supprimer. Et puisque vous avez n-calls à placement-new, vous devez appeler manuellement le destructeur n fois.

Donc, vous voudrez peut-être quelque chose comme ceci:

// Allocate an array of chars instead of an array of MyListNode. Since we 
// are going to use placement new, this is necessary if MyListNode has a 
// a default constructor 
MyListNode* pool = static_cast<MyListNode *>(new char[sizeof(MyListNode) * length); 
for (size_t position = 0; position < length; ++position) 
    new(&pool[position]) MyListNode(); 

... 

for (position = 0; position < length; ++position) 
    pool[position].~MyListNode() 

delete[] static_cast<char *>(pool); 

Answer 2

La possibilité évidente serait de vérifier l'adresse de l'objet, et de ne l'effacer que si elle se trouve en dehors de votre piscine. Si je le faisais, je pense que je surchargerais probablement operator new pour la classe, et l'allouerais toujours l'espace de votre piscine. De cette façon, vous obtenez votre allocation contiguë sans copier, et vos objets sont attribués uniformément afin que vous puissiez les supprimer uniformément.