Discussion :

[loufoque]

Je vois pas trop ce qu'il y a à détailler.
Pour différer la construction il suffit d'appeler le constructeur sur une zone mémoire brute, qui peut très bien être allouée sur la pile par exemple.

Ce qui signifie alors qu'il ne faut appeler le destructeur explicitement et que si le constructeur a bien été appelé etc. On a d'ailleurs les mêmes problèmes avec l'allocation dynamique.
On peut fortement limiter ces problèmes on enveloppant ça dans une classe qui utilise en plus un booléen pour savoir si la mémoire est initialisée ou pas. C'est ce qu'est boost.optional.

De toutes manières, tu ne devrais pas avoir à différer la construction. Ici le problème c'est parce que tu utilises des tableaux. Utilise std::vector à la place et plus de problème.

[progfou]

Je ne peux pas utiliser std::vector, il faut lire !

[Patriarch24]

Je vois pas trop ce qu'il y a à détailler.
Pour différer la construction il suffit d'appeler le constructeur sur une zone mémoire brute, qui peut très bien être allouée sur la pile par exemple.

Ce qui signifie alors qu'il ne faut appeler le destructeur explicitement et que si le constructeur a bien été appelé etc.

Ca s'appelle un placement new. Je ne vois pas vraiment l'intérêt d'utiliser cette technique dans du code en dehors de l'écriture d'un allocateur.

On a d'ailleurs les mêmes problèmes avec l'allocation dynamique.

Quels problèmes ? Celui d'appeler explicitement le destructeur ? Cette solution est complexe et fortement sujette à erreurs (notamment parce qu'on oblige à appeler le destructeur explicitement, ce qui n'est pas vraiment naturel).

On peut fortement limiter ces problèmes on enveloppant ça dans une classe qui utilise en plus un booléen pour savoir si la mémoire est initialisée ou pas. C'est ce qu'est boost.optional.

On peut aussi lever des exceptions depuis les constructeurs pour signifier que quelque chose s'est mal passé.

De toutes manières, tu ne devrais pas avoir à différer la construction. Ici le problème c'est parce que tu utilises des tableaux. Utilise std::vector à la place et plus de problème.

Absolument d'accord. J'aimerais aussi comprendre pourquoi cette restriction sur l'utilisation de std::vector...

[progfou]

La question du std::vector est (apparemment, moi je ne fais que faire ce que l'on me demande) une raison de portabilité du code.

[Patriarch24]

Portabilité ? Mais c'est standard ! Donc ça devrait être portable !!

[progfou]

Par curiosité, comment changer le code pour utiliser std::vector ?
Et puis, si je veux faire passer l'idée, il me faut argumenter (et sec !), donc prouver que c'est mieux, et expliquer que ça fonctionnera dans tous les cas...

[Patriarch24]

C'est simple :

Code :

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

1
2
std::vector<QuelqueChose> v;
v.push_back(QuelqueChose(/*...*/));//ajoute un élément en fin de vecteur

Les vecteurs sont des tableaux dynamiques (ce qui permet de ne pas avoir à connaître leur taille par avance). On peut utiliser tous les algorithmes standards dessus (voir l'entête algorithm), ce qui évite de réinventer la roue, et son utilisation est parfaitement semblable à celle des tableaux (accès aux éléments via l'opérateur [] notamment, ou par la fonction at pour checker les bornes).

Pour plus d'informations, il vaut mieux lire la doc dessus (ici par exemple).

[progfou]

Dans mon cas, j'ai :

Code :

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

QuelqueChose tableau[2];

Je peux écrire :

Code :

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

std::vector<QuelqueChose> tableau[2];

?

Du coup, je conserve mes delete ?
Qu'est-ce que ça change concrètement quand à ma classe ?

[poukill]

Code :

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

std::vector<QuelqueChose> tableau;

suffit

Les méthodes pour rajouter des éléments sont:
push_back() : vers la fin
push_front() : au début
insert() : ou tu veux (moins rapide)

Après, tu peux réserver de la mémoire si tu veux, mais ce n'est pas nécessaire, avec la méthode reserve();

Voilà!

[Patriarch24]

std::vector<QuelqueChose> tableau[2];

Non juste :

std::vector<QuelqueChose> tableau;

Si tu veux réserver deux emplacements, tu fais :

std::vector<QuelqueChose> tableau(2);

qui appelle le constructeur de std::vector en réservant deux emplacements.

Du coup, plus besoin d'appeler delete car le vector sera détruit en même temps que l'objet englobant. Attention cependant : si le vecteur contient des pointeurs, il faudra les détruire soit même (le conteneur n'a pas cette responsabilité).