Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre à l'essai
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    juillet 2018
    Messages
    21
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : juillet 2018
    Messages : 21
    Points : 20
    Points
    20

    Par défaut vecteur de pointeur sur objet : nu et smart - ai-je bien tout compris ?

    Bonjour la communauté,

    Ci dessous 2 codes (minimal) qui (je pense) fonctionnent pour gérer une collection d'objet via un Vector :

    "A l'ancienne" donc avec des pointeurs nus :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    {
    std::vector <Objet *> vPobjet; // Objet est une classe définie par ailleurs
    for(int i=0; i<5; i++) vPobjet.push_back(new Objet()); // 5 Pointeurs vers 5 nouveaux objets poussés dans le vector
    ...
    vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
    ...
    vPobjet[2] -> destruct(); // utilisation d'une méthode qui appelle le destructeur de la classe (destruction de l'objet 3)
    delete vPobjet[2]; // libération de la mémoire occupée par l'objet 3 maintenant détruit
    vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
    }
    En C++ "moderne" donc avec des pointeurs smart :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    {
    std::vector <std::unique_ptr<Objet>> vPobjet; // Objet est une classe définie par ailleurs
    for(int i=0; i<5; i++) vPfenetre.push_back(std::make_unique<Objet> ()); // 5 Pointeurs uniques vers 5 nouveaux objets poussés dans le vector <= Ici "emplace_back" est peut être préférable ?
    ...
    vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
    ...
    vPobjet[2] -> destruct(); // utilisation d'une méthode qui appelle le destructeur de la classe (destruction de l'objet 3)
    // PAS DE DELETE Pke Pointeur smart (il se débrouille pour libérer la mémoire) :D
    vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
    }
    Normalement dans les 2 cas je n'ai pas de fuite mémoire... Est-ce correct ?

    Rick.

  2. #2
    Expert confirmé
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    946
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 946
    Points : 4 829
    Points
    4 829

    Par défaut

    Bonjour,

    Je suis d'accord sauf que je ne comprends pas du tout ce que tu fais ligne 8 pour tes 2 codes. C'est quoi cette fonction destruct() ? Il ne faut pas détruire l'objet 2 fois! Et s'il y a des choses supplémentaires pourquoi ne sont-elles pas dans le destructeur de Objet.

  3. #3
    Expert éminent sénior
    Avatar de koala01
    Homme Profil pro
    Consultant informatique
    Inscrit en
    octobre 2004
    Messages
    11 176
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : Belgique

    Informations professionnelles :
    Activité : Consultant informatique

    Informations forums :
    Inscription : octobre 2004
    Messages : 11 176
    Points : 27 582
    Points
    27 582

    Par défaut

    Salut,

    Le destructeur est la seule fonction d'une classe qui ne doive JAMAIS (*) être appelée de manière explicite à partir d'une instance de la classe!!!

    Ni de manière directe, sous une forme qui serait proche de
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    int main(){
         Object * ptr= new Obejct;
         /* ... */
         ptr->~Object();
    }
    ni de manière indirecte, sous une forme qui serait proche de
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    int main(){
         Object * ptr= new Obejct;
         /* ... */
         ptr->destruct(); // fonction qui fait appel à ~Object()
    }
    La raison en est simple : le destructeur est appelé systématiquement et automatiquement par le compilateur
    1- lorsqu'on quitte la portée d'une variable:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    void foo(){
        Oject obj;
        /* ...*/ 
    } /* obj est automatiquement détruit (et son destructeur automatiquement appelé-
       * ici, parce qu'il n'est plus accessible au delà  de ce point
       */
    2- lorsque l'on invoque delete (ou delete[]) sur un objet dont la mémoire a été alloué de manière dynamique au travers de new (ou de new [] , sous une forme proche de
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    void foo(){
         Object * ptr= new Obejct;
         /* ... */
         delete ptr; // delete fait appel au destructeur de l'objet
    }
    (*) Bien sur, il y a des exceptions à cette règle, comme pour toutes les règles "un peu trop strictes", mais tu auras largement l'occasion de les apprendre "plus tard". Contentes toi donc de l'appliquer à la lettre dans un premier temps

    Ton code devrais donc prendre une forme qui serait plus proche de quelque chose comme
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    {
    std::vector <Objet *> vPobjet; // Objet est une classe définie par ailleurs
    for(int i=0; i<5; i++) vPobjet.push_back(new Objet()); // 5 Pointeurs vers 5 nouveaux objets poussés dans le vector
    ...
    vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
    ...
    delete vPobjet[2]; // libère la mémoire allouée à l'objet 3 (et appelle le destructeur pour ce faire)
    vPobjet[2] = nullptr;  // indique explicitement que ce pointeur représente une adresse mémoire invalide
    vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
    }
    Quant à l'utilisation des pointeurs intelligents, elle prendrait une forme proche de
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    {
    std::vector <std::unique_ptr<Objet>> vPobjet; // Objet est une classe définie par ailleurs
    for(int i=0; i<5; i++) vPfenetre.push_back(std::make_unique<Objet> ()); // 5 Pointeurs uniques vers 5 nouveaux objets poussés dans le vector <= Ici "emplace_back" est peut être préférable ?
    ...
    vPobjet[3] -> faitUnTruc(); // utilisation d'une méthode de la classe de l'objet 4
    ...
    vPobjet[2].reset(); // ordonne au pointeur de libérer l'espace mémoire alloué à son pointeur sous-jacent
                         // en invoquant delete dessus et en appelant donc le destructeur de manière correcte
    // PAS DE DELETE Pke Pointeur smart (il se débrouille pour libérer la mémoire) :D
    vPobjet.erase(vPobjet.begin + 2); // "effacement" du pointeur vers l'objet 3 maintenant détruit
    }
    Pour le reste, tu as effectivement compris le principe : la classe std::unique_ptr prend la responsabilité complète de la gestion du pointeur sous-jacent qu'on lui fournit, et veille bel et bien à libérer la mémoire qui y a été allouée au moment opportun
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  4. #4
    Membre à l'essai
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    juillet 2018
    Messages
    21
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : juillet 2018
    Messages : 21
    Points : 20
    Points
    20

    Par défaut

    Tout à fait d'accord, on ne détruit qu'une fois. ^^
    J'avais juste un doute sur la pertinence à mettre le destructeur en "Public"...
    Effectivement, au vu de ce qu'explique Koala, le rôle joué par "delete" est plus complet que je ne l'avais compris.

    Du coup, je pense que ce petit sujet va trouver toute sa pertinence auprès les débutants enthousiastes mais isolés.
    Merci à tous, sujet clos pour moi.

    Rick.

  5. #5
    Modérateur

    Avatar de Winjerome
    Homme Profil pro
    Inscrit en
    septembre 2009
    Messages
    10 415
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations forums :
    Inscription : septembre 2009
    Messages : 10 415
    Points : 53 860
    Points
    53 860

    Par défaut

    Bonjour,

    Citation Envoyé par Rick_Cplusplus Voir le message
    Normalement dans les 2 cas je n'ai pas de fuite mémoire... Est-ce correct ?
    Les pointeurs intelligents : pas de soucis, autre que ceux évoqués par koala01.

    Les pointeurs nus…
    • Tu ne delete que le pointeur d'indice 2. Que fais-tu des 4 autres ?
    • Que se passe-t-il si un de tes new échoue et lance une exception ?
    • Que se passe-t-il si un push_back() échoue et lance une exception ?
    • Que se passe-t-il si faitUnTruc() ou ce qu'il y a dans les ... lance une exception ?
    Avant de poser votre question : FAQ, Tutoriels et recherche sur le forum
    Une erreur ? Messages d'erreur et avertissements
    "Ça ne marche pas" n'apporte aucune information utile permettant de vous aider. Expliquez clairement votre problème (erreurs entières, résultat souhaité vs obtenu...).
    En essayant continuellement on finit par réussir. Donc: plus ça rate, plus on a de chance que ça marche. - Jacques Rouxel
    L'expérience, c'est le nom que chacun donne à ses erreurs - Oscar Wilde
    Mes extensions FireDVP (Firefox), ChroDVP (Chrome) : suivi des nouveaux messages, boutons/raccourcis et bien plus !

  6. #6
    Membre à l'essai
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    juillet 2018
    Messages
    21
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : juillet 2018
    Messages : 21
    Points : 20
    Points
    20

    Par défaut

    Citation Envoyé par Winjerome Voir le message
    Bonjour,

    Les pointeurs nus…
    • ...
      la liste de question
      ...

    Oui oui je connais les défaut inhérents aux pointeurs nus (c'est bien expliqué dans la FAQ de ce site par ailleurs). c'est pour ça que j'avais écrit : "Normalement, dans les 2 cas..."
    Je suis personnellement convaincu qu'un pointeur smart (unique dans ce cas) c'est bien plus sûr, mais je voulais avoir confirmation (et correction ) de la gestion de ceux-ci avec un vector.
    Koala a été très clair, et en plus m'a confirmé qu'un "delete" appelle le destructeur de l'objet pointé ce dont je n'étais pas certain. Merci encore d'aider ainsi les apprentis.

    Rick.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. pointeurs sur objets en C #
    Par lemya dans le forum C#
    Réponses: 3
    Dernier message: 02/01/2008, 12h13
  2. Pointeur sur objet different
    Par peruvio dans le forum C++
    Réponses: 4
    Dernier message: 19/11/2007, 20h06
  3. Pointeur sur objet
    Par bubulemaster dans le forum Débutant
    Réponses: 5
    Dernier message: 26/09/2007, 09h10
  4. Tableau de pointeurs sur objets
    Par bassim dans le forum C++
    Réponses: 11
    Dernier message: 13/12/2005, 19h45
  5. [Debutant VC++.net] Obtenir un pointeur sur objet
    Par SteelBox dans le forum MFC
    Réponses: 6
    Dernier message: 17/06/2004, 18h36

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo