C ++: push_back (new Object ()) est-il une fuite de mémoire?

Est le code C++ suivant une fuite de mémoire?

list.push_back(new String("hi"));

Comme je le comprends, push_back contre les mst collection/conteneur toujours fait une copie. Donc, si la nouvelle chaîne est copié, rien ne pourra jamais supprimer le nouveau avais chaîne droite? comme il n'existe pas de référence après le push_back...

Ai-je raison ou tort?

Grâce.

Jbu

edit: je pense que je suis dans l'erreur, puisque de nouvelles retournera un pointeur...nous aurons toujours le pointeur pour être en mesure de supprimer la nouvelle Chaîne

source d'informationauteur jbu

  1. 6

    Non, le vecteur stocke des pointeurs et de la copie du pointeur. Vous pouvez supprimer l'objet à tout moment plus tard.

    (Vous pouvez obtenir une fuite, si l'état arrive à lancer une exception, et vous n'avez pas l'attraper et de le gérer correctement. C'est pourquoi vous pourriez envisager d'utiliser des pointeurs intelligents.)

  2. 8

    Oui, mais pas pour la raison que vous pensez.

    En fonction de la façon dont list est défini et initialisé, push_back peut lever une exception. Si c'est le cas, le pointeur retourné à partir de new est perdu, et ne peut jamais être libéré.

    Mais en supposant que push_back retourne avec succès, il stocke une copie du pointeur retourné par newet ainsi nous pouvons nous libérer de la mémoire, plus tard, en appelant delete sur cet exemplaire, donc pas de fuites de mémoire aussi longtemps que vous ne appel delete correctement.

  3. 4

    Si j'ai vu ce code, je serais très suspecte une fuite de mémoire a été possible. Sur la surface, cela semble être l'ajout d'un alloués String* dans un list<String*>. Dans mon expérience, c'est souvent suivie par la mauvaise gestion des erreurs de code qui ne gère pas correctement libérer la mémoire allouée.

    Tout ce dangereux dans de nombreux cas, il n'est pas nécessairement une fuite de mémoire. Considérons l'exemple suivant:

    class Container {
  ~Container() {
    std::list<String*>::iterator it = list.begin();
    while (it != list.end()) {
      delete *it;
      it++;
    }
  }

  void SomeMethod() {
    ...
    list.push_back(new String("hi"));
  }

  std::list<String*> list;
}

    Dans ce code il n'y a pas de fuite parce que le contenant de la classe est responsable de l'allocation de la mémoire et de la volonté libre dans le destructeur.

    MODIFIER

    Comme aschepler a souligné il y a encore une fuite si le push_back méthode lève une exception.

  4. 1

    Vous êtes correct, à condition de ne rien supprime la chaîne lorsqu'il est retiré de la liste.

  5. 1

    Oui, c'est une fuite de mémoire si vous en quelque sorte de prendre des mesures pour supprimer le contenu des pointeurs.

    Et le meilleur moyen d'y arriver est d'utiliser un pointeur intelligent. Par exemple, augmentez la shared_ptr ou C++0x du shared_ptr.

  6. 0
    list.push_back(new String("hi"));

    Pourquoi êtes-vous l'allocation dynamique des chaînes en premier lieu? Sauf si vous voulez communiquer entre les différentes parties de votre programme par le changement des cordes (ce qui serait tout à fait inhabituel), de se débarrasser du pointeur:

    std::list<std::string> list;         //note: no pointer!
list.push_back(std::string("hi"));   //explicitly create temporary
list.push_back("hi");                //alternative: rely on coercion
  7. 0

    Pas.

    Vous pouvez supprimer l'objet en faisant:

    delete list[i];
list.erase(list.begin() + i);

    ou effacer toute la liste par:

    for (unsigned int i = 0; i < list.size(); ++i)
{
  delete list[i];
}
list.clear();