Discussion :

[camboui]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int i=une_valeur;
void *pv=operator new(sizeof(UneClasse)*i);
UneClasse *puc=new(pv) UneClasse [i];

delete [] puc;//crash !!!

Question simple ou complexe, je ne sais pas. Comment fait-on un delete d'un tableau construit par displacement new ?

Faut-il faire explicitement comme ceci ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int i=une_valeur;
void *pv=operator new(sizeof(UneClasse)*i);
UneClasse *puc=new(pv) UneClasse [i];
 
for (int x=0;x<i;++x)
 (&puc[x])->~UneClasse();
operator delete(pv);

Merci.

EDIT: en fait même la deuxième écriture crash. Ceci semble fonctionner:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
int i=une_valeur;
void *pv=operator new(sizeof(UneClasse)*i);
 
int x;
UneClasse *puc=reinterpret_cast<UneClasse *>(pv);
for (x=0;x<i;++x)
 new(&puc[x]) UneClasse;
 
for (x=0;x<i;++x)
 (&puc[x])->~UneClasse();
operator delete(pv);

[Médinoc]

Je pense que oui.
Sauf que tu dois pouvoir simplifier cette ligne:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

(&puc[x])->~UneClasse();

En ceci:

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

puc[x].~UneClasse();

[Mat007]

(placement new)

MAT.

[camboui]

J'ai mis en gras la ligne litigieuse dans le premier post. Il semble qu'elle soit problématique car le pointeur pv ne pointe pas sur une zone mémoire de taille suffisante, sizeof(UneClasse)*i étant "trop petit".

Personne n'utilise le placement new avec des tableaux ? Quels sont les règles pour allouer correctement suffisemment d'espace ? Commen libérer la mémoire à la fin de l'utilisation avec appel du destructeur pour chaque élément du tableau ?
Merci.

Un début de réponse ici, mais ce n'est pas très complet:
http://www.cplusplus.com/reference/s...new%5B%5D.html

[zais_ethael]

Franchement, moi j'aurais tout simplement fait un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
char* tab=new char[ta_taille];
...
delete[] tab;

Parce que ce new là, "non typé" ou "typé void", j'en ai jamais entendu parler. Par contre on aura tous compris que tu veux réserver x bytes de mémoire, et pour ça un new char[] est tout ce dont tu as besoin.

J'aurais aussi fait une itération pour appeler les constructeurs au lieu d'utiliser cette syntaxe qu'encore une fois je ne connais pas. Avec une itération je suis sur que ça marchera par contre en devinant le fonctionnement de cet appel j'imagine des cas d'erreur.

[3DArchi]

Je me demande si ce n'est pas dû à un problème d'alignement. Quand je reprends ton exemple puc et pv n'ont pas la même adresse. Donc, t'as du déborder.

[camboui]

...
delete[] tab;[/code]Parce que ce new là, "non typé" ou "typé void", j'en ai jamais entendu parler. Par contre on aura tous compris que tu veux réserver x bytes de mémoire, et pour ça un new char[] est tout ce dont tu as besoin.

Comme tu ne sembles pas connaître le "placement new", je t'invite à lire ceci
http://www.cplusplus.com/reference/s...new%5B%5D.html ainsi que les liens qui s'y trouve et concernant operator new [] et operator delete [].
Je suis loin d'en connaître toutes les subtilités, raison de cette discussion d'ailleurs

Et non je ne veux pas allouer x bytes en mémoire, je veux construire un tableau d'objets dans une zone mémoire existante. Puis le détruire.

Donc la question est: comment utiliser les "placement new" avec les tableaux ?
En principe les compilateurs doivent gérer implicitement chaque élément du tableau en appelant leur constructor lors du "placement new" et leur destructor lors du "placement delete". Mais ça ne fonctionne pas comme je le voudrais. Donc quels sont les régles en C++ pour savoir si on a alloué assez d'espace mémoire ?
get_temporary_buffer et return_temporary_buffer sont-ils la réponse, est-ce standard ?

[camboui]

Je me demande si ce n'est pas dû à un problème d'alignement. Quand je reprends ton exemple puc et pv n'ont pas la même adresse. Donc, t'as du déborder.

En effet. Il semble que le compilateur se réserve un entier en plus de la taille nécessaire au tableau pour y mémoriser le nombre d'éléments car il faut bien qu'il connaisse ce nombre lors de la destruction du tableau.
Mais bon, c'est un constat empirique. Quelle est la règle "standard" ?

[Nogane]

Bonjour,
Sur minGW, l'exemple du premier post ne plante pas. Mais il est vrai que ça peu dépendre du compilateur.

Pour être sur d'allouer de l'espace pour un tableau, essaie avec l'opérateur new sur les tableau:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void *pv = operator new[](sizeof(bidul) * i);

[camboui]

Merci.
Sous VC++6 ça ne compile pas. Et sous VS2005 ça ne change rien de mettre [] ou pas.
De toute façon je ne parviens pas à trouver l'équivalent d'un "placement delete", c'est à dire demander au compilateur qu'il appelle implicitement les destructor sans désallouer la mémoire (l'opération inverse du "placement new"). J'en suis réduit à faire une boucle et appeler le destructor de chaque élément un par un.
Bon, donc tant pis, j'en conclus qu'il n'y a pas de prise en charge standard du placement new pour les tableaux. Je ferais les boucles moi-même.

[3DArchi]

Au delà de la question de principe, on peut se poser la question de pourquoi tu as besoin de faire un placement new sur un tableau ? Je ne vois pas quel cas peut le nécessiter.
Je me demandais si ton besoin ne peut être rempli par Boost.optional : tu crées un vecteur de boost.optional<MaClasse> que tu peux ensuite effectivement construire et détruire au besoin.

[white_tentacle]

Le placement new n'alloue pas la mémoire.

J'aurais donc tendance à dire qu'il ne faut pas faire un delete dessus...

Pour détruire tes objets :
- appeler delete sur chacun des éléments de ton tableau
- libérer la mémoire avec un delete pv (et pas un delete[], puisqu'il a été alloué avec new, et pas puc, puisqu'il n'a pas été alloué mais placé).

[3DArchi]

Le placement new n'alloue pas la mémoire.

J'aurais donc tendance à dire qu'il ne faut pas faire un delete dessus...

Pour détruire tes objets :
- appeler delete sur chacun des éléments de ton tableau
- libérer la mémoire avec un delete pv (et pas un delete[], puisqu'il a été alloué avec new, et pas puc, puisqu'il n'a pas été alloué mais placé).

Ca revient à faire sa troisième solution du premier post. Si j'ai bien compris le bp, c'est de pouvoir automatiquement appeler le destucteur sur tous les éléments du tableau sans avoir à faire la boucle (comme pour le placement new). Mais, j'ai l'impression que ce n'est pas possible ; le delete appelant le destructeur puis détruisant la mémoire.

[Nogane]

Cela n'est pas toujours possible, mais une autre solution serai de surcharger les opérateur new et delete de la class, pour leur donner le comportement voulu. Ainsi un new[] et delete[] "normaux" suffiront.
Une autre solution, (mais plus dangereuse) serai de ne surcharger que le delete, pour qu'il ne fasse rien.