J'ai une classe d'objet C ++ comme ceci: Edit: Si je déclare composant code> s ajouté à
objet de classe code> est
Supprimer code> d sur une autre fonction qui n'est pas liée à ma question. Afaik faisant beaucoup de
neuf code> /
Supprimer code> appels (allocations de tas) Blesser les performances et supposé qu'il devrait y avoir 20/30 (ou même plus)
Objets Code > S avec 3-10
Object :: Ajouter code> sur chacun. Je pensais que je pouvais juste appeler
t code> -s constructeur sans
nouveau code>, puis sur
static_cast
int code>, ils sont tous égaux à
0 code> au lieu d'une valeur personnalisée transmise son constructeur). Je suis conscient que
valeur code> est hors de portée et le pointeur sur la carte
code> devient pendante, mais je ne trouve pas un moyen d'instancer
t Code> Objets sans appeler
Nouveau code> ou sans les déclarer comme
statique code>. Y a-t-il un moyen de faire cela? P>
valeur code> comme
statique code>, tout fonctionne comme prévu, donc je suppose que c'est un problème de vie liée à
valeur code>. p> p>
3 Réponses :
Je suppose que vous pensez à cela comme la voie alternative de créer vos objets ceci crée une variable locale sur la pile. Faire la mission alors, stocke un pointeur à une variable locale dans la carte code>. P> Lorsque vous laissez la méthode Tant que vous voulez stocker des pointeurs, il n'y a aucun moyen de ne pas courir neuf et de la suppression. Vous pouvez l'atténuer un peu avec une sorte de Pool de mémoire . P> Si vous pouvez également stocker des objets au lieu de pointeurs sur la carte, vous pouvez créer les composants en place avec add () code>, l'objet local sera Détruit, et vous avez un pointeur pendant sur la carte. Ceci, à son tour, vous mordre finalement. P>
std :: Map :: Emplace Code>
. Lorsque vous faites cela, vous devez également supprimer l'appel sur Supprimer code> et nettoyer les objets d'une autre manière. P> P>
Je vois. Le code fonctionne bien si j'ajoute statique code> lors de la construction code> (CODE> (STH comme:
C ++ statique t valeur {std :: Forward
std :: map code> s de
statique code> variables.
Essayer d'éviter les allocations de tas avant d'avoir prouvé qu'ils blessent en effet la performance de vos programmes n'est pas une bonne approche à mon avis. Si tel était le cas, vous devriez probablement vous débarrasser de std :: map code> dans votre code aussi. Cela étant dit, si vous voulez vraiment n'avoir aucun
nouveau code> /
Supprimer code> Appels, cela peut être effectué, mais nécessite une énumération explicite du composant
code> les types. Quelque chose comme ça pourrait être ce que vous recherchez:
composant code> énumère tous les types de composants connus, cela permet d'éviter une allocation dynamique dans
objet code >, mais peut augmenter l'utilisation de la mémoire, car la mémoire utilisée pour un seul objet
est grossièrement code> Number_of_component_types * Taille_of_larges_Component code>. p> p>
J'ai besoin des structures déroulantes du composant pour contenir des données spécifiques (ex. Une classe d'animationComponce conserve des données liées à l'animation). Le composant code> de base code> était utilisé pour avoir un point commun pour tous les composants afin que je puisse écrire un concept code> à utiliser dans Ajouter code>. Je sais que je suis peut-être franchir la ligne avec mes "exigences", mais
#include code> s "objet.h "(Le fichier où
composant de classe code> est déclaré). Cela signifie que
à l'aide de composant code> doit être modifié par quiconque, qui est suone d'erreur sur mon cas.
tandis que les autres réponses ont clairement indiqué ce que le problème est que je veux faire une proposition en quoi vous pourriez vous déplacer dans son intégralité.
Vous savez à la compilation Quels types possibles seront sur la carte de Mosz, puisque vous Sachez quelle instantanation du modèle code> code> utilisé. Vous pouvez donc vous débarrasser de la carte et faire tout dans un temps de compilation. P> Bien sûr que cela vous oblige à collecter tous les objets possibles lorsque vous créez l'objet, mais cela Pas plus d'info que vous devez avoir juste plus pratique. p> Vous pouvez ajouter la surcharge suivante pour Ajouter code> pour que les erreurs facilitent la lecture p>
En tant que mater de fait, je ne sais pas à la compilation des types exacts que la carte tiendra la carte, mais je sais que ces types sont tous dérivés d'un composant vide code>, donc j'ai écrit
Modèle
modèle
std :: facultatif code> peut être retiré facilement du code sans aucun effet secondaire.
Vous ne pouvez supprimer que le en option code> si vous pouvez construire toutes les classes lorsque vous construisez l'objet (E.G. si tout est constructible par défaut). Mais le facultatif n'est pas un problème, il ne fait pas d'allocations de tas, mais est essentiellement juste assez d'espace pour l'objet et un drapeau si c'est là ou non. Et si vous ne savez pas quels composants peuvent être là (non, mais peut être), vous avez un problème avec votre code ci-dessus. Depuis chaque composant que vous avez, vous devez instancier le modèle
ajouter code> avec le type de bon type comme T.
Pouvez-vous expliquer le problème sous-jacent que vous essayez de résoudre?
Désolé mon mauvais. J'essaie de supprimer ces
nouveau code> /
Supprimer les appels code>, mais comme @Oolaf DIetsche mentionné, si j'écris l'extrait qu'il a partagé,
la valeur code> la variable Sortez hors de portée et
Composants CODE> La carte contiendrait des pointeurs suspendus. Si je déclare
valeur code> comme
statique code>, il aurait la durée de vie des programmes et le problème résolu, mais je veux trouver un moyen de créer moins cher
t code> s et les stocker sur
composants code> Carte (autre que d'utiliser
Nouveau code> /
statique code>).