Discussion :

[dream25]

Bonjour à tous.
Je vous explique mon problème. Je suis en train de développer un petit tower defense sur pc. Je possède une classe abstraite CTour qui renferme les propriétés de base d'une tour classique. J'ai ensuite plusieurs classes dérivées de cette classe (par exemple tour de feu, tour de glace etc...). Je peux faire référence à chaque tour grâce à une liste de pointeurs CTour* qui regroupe tous les pointeurs de mes tours.

Normalement pour ajouter une tour, j'ai juste à réaliser un "push_back" de la nouvelle tour à la fin de cette liste. Mais voilà je souhaite éviter au maximum les allocations dynamiques en cours de programme. Je voudrais du coup créer un manager de tours qui allouerait au tout début de mon programme toutes mes instances et qui s'occuperait de me renvoyer un pointeur sur une de ces instances lorsque je déciderais d'ajouter une nouvelle tour.

Mon problème est le suivant : comment réaliser l'allocation de mémoire pour ce manager. Je ne peux pas par exemple faire ceci : new CTour[100] car ma classe CTour est abstraite. De plus Je ne connais pas à l'avance le type de tour et les quantités dont je vais avoir besoin.

Une solution serait d'allouer 100 fois chaque type de tour mais je ne pense que ce soit une bonne solution.
Sinon j'avais pensé à créer une union de toutes mes classes de tours et d'instancier 100 fois cette union. Ainsi la place en mémoire de la plus grosse tour de l'union serait utilisée pour l'allocation au début de programme, et je pourrais caster cette mémoire en le bon type de tour lorsque que j'ajouterais une tour de feu par exemple. Est-ce une bonne solution ou y'en a-t-il une meilleure à laquelle je n'ai pas pensé ?

[Trademark]

Bonjour,

j'ai la vague impression que tu fais tu C with classes En C++ tu pourrais par exemple faire un :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
#include <vector>
 
class CTour
{};
 
class TourFeu : public CTour
{};
 
int main()
{
  std::vector<CTour*> tours ;
  tours.reserve(100); // Ne sert pas a grand chose car on alloue seulement pour des pointeurs.
  tours.push_back( new TourFeu() );
  return 0;
}

Et voila Mais attention, avec un .reserve tu ne peux pas accéder au élément via [] (tours[5]) s'ils n'ont pas déjà été "pushé". Utilise .resize() si tu veux faire ça.

EDIT : Code édité selon la remarque de Flob.
EDIT2 : Code édité selon la remarque de Cob.

[Flob90]

@Trademark: Tu oublies les pointeurs, sans eux pas de polymorphisme (ou référence mais ca ne va pas avec les conteneur).

@OP: Le "reserve" va te permetre d'allouer en avance la mémoire nécessaire pour stocker les pointeurs dans le conteneur. Pour ton problème, regardes du coté des allocateurs pour petits objets ou des pools de mémoire (Loki::SmallObject, boost::pool par exemple), cependant fait des tests c'est le seul moyen de savoir si ca optimisera ou non ton code.

[cob59]

Honnêtement, une allocation dynamique de tes CTour te semble-t-elle vraiment pénalisante ?

Je doute que l'utilisateur se mette à créer/détruire des centaines de CTour à la seconde, quand bien même le GUI le lui permettrait. Ça me semble être le parfait exemple d'une optimisation prématurée qui ne t'apportera que des ennuis.

Pour ce qui est de l'exemple de TradeMark, le reserve() ne va pas servir à grand chose puisqu'il allouera seulement une série de pointeurs vers des objets CTour, et pas les objets eux-même.

[dream25]

En fait ce n'est même pas que je veux optimiser mon code (même si au final c'est le résultat) c'est juste que par principe, si on m'oblige à ne pas faire d'allocation dynamique au cours du jeu je voudrais savoir comment gérer ça. Il doit bien exister un moyen pas trop compliqué ? Je suis en train de créer mon moteur et j'aimerai avoir la solution car je compte tout gérer via des managers (cameras, particules, objets...)

Si j'utilisais un seul type de tour, ce sera plié avec un new CTourDefeu[100] en début de programme et un tableau de booléens pour dire si oui ou non la tour est libre. Mais là avec l'héritage je ne m'y connais pas assez pour savoir comment m'y prendre.

[cob59]

Un pool serait une bonne solution. (boost::pool est cité au dessus)
Tu crées autant de pool qu'il existe de classes non-abstraites héritant de CTour. Tu te bases sur l'exemple de Trademark sauf qu'au lieu d'utiliser new TourFeu() tu utilises le pseudo-constructeur de ton pool qui te retourne un pointeur de type TourFeu*. Idem pour le destructeur.

[dream25]

D'accord merci je vais regarder ça, ça a vraiment l'air d'être ce que je cherche. Et théoriquement, si je n'ai pas le droit d'utiliser des libs comme boost, comment le faire à la main ? (oui je sais je suis un peu ennuyeux mais j'aimerais bien comprendre comment gérer ce genre de problème de mémoire, cast, héritage).

Il me semblait que faire une union de tous mes types de tour et d'allouer 100 fois cette union était une bonne solution ou bien est-ce horrible ? Qu'en pensez-vous ?