Discussion :

[MrPchoun]

Bonjour,

Y a-t-il une fuite de mémoire dans le code suivant ?

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
std::vector<void*> components;
 
struct Component
{
    unsigned index;
 
    Component() : index(components.size()) {};
 
    ~Component()
    {
        std::swap(components[index],components.back());
        components.pop_back();
    }
};
 
struct Position : Component {};
 
struct Name : Component {};
 
int main()
{
    components.push_back(new Position);
    components.push_back(new Name);
    components.push_back(new Name);
    components.push_back(new Position);
    components.push_back(new Name);
 
    Name* e = static_cast<Name*>(components[2]);
    delete e;
 
    return 0;
}

Normalement, on fait d'abord delete, puis ensuite on enlève l'élément dans le vector, mais dans mon cas, je ne sais pas trop comment ça va se passer étant donné que delete appelle le destructeur, où justement je supprime l'élément du vector

[user019]

Est-ce que ce code fuit? Il me semble que non.

Est-ce que ce code est donc bien fichu? Oh que non.

Une classe qui fait référence en dur à une variable globale qui contiendra toutes ses futures instances? Mmh. Pas sûr que ce pattern connaisse un grand succès.

Si tu expliques quel est le but de ton code, on peut t'orienter vers une solution plus standard.

[MrPchoun]

Bah, faut dire aussi, c'est un code minimal, en pratique y aura pas de variable globale, par contre elle contiendra effectivement toutes mes instances, pour épargner ma mémoire cache.

Le but du code ? En gros.

J'ai ce vector de components, et un autre vector (system) que je n'ai pas fait figurer ici, qui contiendra des pointeurs sur ces components. Je veux pouvoir supprimer facilement ces components depuis system sans avoir à tenir un registre où j'enregistre à quelle position j'ai enregistré tel component.

[jblecanard]

Un vector de void* c'est pas sérieux ça

par contre elle contiendra effectivement toutes mes instances, pour épargner ma mémoire cache.

Cette opitmisation me paraît bien prématurée. Early optimization is the root of all evil. Avant d'optimiser, on fait du profiling. Pour l'instant, tu es en au design, pas encore au profiling. En plus, elle ne fonctionne pas : si tu stockes des pointeurs, les components ne seront pas contigus et ton optimisation de cache ne sert à rien ! Après je suppose que Component est polymoprhique, dans lequel cas tu n'as pas le choix, tu ne pourras pas les stocker de manière contigue facilement.

Je veux pouvoir supprimer facilement ces components depuis system sans avoir à tenir un registre où j'enregistre à quelle position

Et pourtant, tu le fais : chaque component enregistre son indice. En plus, ça ne fonctionne pas : si tu supprimes un élément au milieu du vecteur, ça va te côuter cher car tous les éléments suivants seront déplacés, et en plus leur indices ne seront plus bon, et les références stockées dans ton system ne le seront plus non plus.

Pour faire le bon choix de la collection, il faut évaluer ton besoin:

• Si tu veux pouvoir supprimer un élément de manière peu coûteuse sans invalider les autres références et que tu ne fais pas ou peu de parcours de la liste : std::list
• SI tu veux faire des parcours de liste efficace : std::vector
• Si tu veux faire les deux : tu es niqué, mais il est probable que std::vector soit meilleur.

Ensuite, c'est une assez mauvaise idée d'utiliser des pointeurs nus, car non seulement c'est risqué, mais en plus tu ne définis pas clairement la politique de propriété de tes composants. Qui est propriétaire de l'objet ?

• Si c'est une propriété partagée entre les systèmes, considère l'usage de std::shared_ptr
• Si la collection "globale" est propriétaire (c'est à dire que le supprimer de la liste est équivalent à le supprimer complètement), utilise std::unique_ptr

Et enfin, las but not least, est-ce que tu ne gagnerais pas du temps à utiliser du code existant ?

[Bousk]

tu mets 5 éléments via new, tu les mets en void*, t'en delete 1 seul, sans destructeur virtuel
et tu te demandes si ça fuit ?

[ternel]

Et ne parlons même pas du fait que tu ne l'a pas enlevé du vector.

Ton idée a un nom: le pattern flyweight.