C++ Vecteurs et les Fuites de Mémoire

J'ai lu quelque part il y a quelque temps que vecteurs provoquer des fuites de mémoire en fonction de la façon dont ils sont utilisés, mais j'aimerais demander, juste pour être sûr:

#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

int main()
{
    vector<somePtr*> listPtrs;

    return 0;
    //Detects memory leaks
}

Et ce n'est pas détecter quoi que ce soit:

#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

int main()
{
    {
        vector<somePtr*> listPtrs;
    }

    return 0;
    //No memory leaks detected
}

Les objets sont supprimés de l'vecteurs avant d'effacer les pointeurs.
Je pense que je me souviens avoir lu que les vecteurs et des listes et des autres mst conteneurs sont automatiquement supprimés après le bloc ils sont, donc dans l'exemple 1-je obtenir de la fuite de mémoire en raison de la fuite de mémoire fonction est appelée avant que le bloc se termine, de sorte que le vecteur est toujours en vie et à l'origine.

Je ne suis pas sûr à ce sujet, il a été un certain temps depuis que je crois que j'ai lu cela, et je ne pouvais trouver des questions à propos des objets n'étant pas supprimé, juste des pointeurs de les retirer.

Est-ce vrai? Et vais-je avoir des fuites de mémoire, si j'utilise une classe globale qui contient les vecteurs et des listes?

std::vector ne pas provoquer des fuites de mémoire, négligent les programmeurs n'.
Vous devez également inclure un exemple qui en fait présente le problème que vous rencontrez, y compris les appels à la CRT de débogage de l'API. Il ya une bonne possibilité que vous êtes qui interprètent mal les fuites basée sur le moment où ils sont déclarés.
Il n'y a pas de fuites de mémoire dans les échantillons que vous avez indiqué.

OriginalL'auteur Danicco | 2013-08-05

  1. 10

    Le point à partir duquel vous appelez _CrtDumpMemoryLeaks est important que la mémoire peut ne pas avoir encore été dévoilé. Par exemple, dans l'exemple ci-dessous si vous appelez _CrtDumpMemoryLeaks() avant listPtrs est hors de portée de toute la mémoire qu'il a alloué sera inclus dans la liste de fuite de mémoire.

    #define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#include <vector>

int main()
{
    std::vector<struct Foo*> listPtrs;

    _CrtDumpMemoryLeaks();

    return 0;
}

    Dans l'exemple ci-dessous listPtrs est hors de portée avant de faire appel à _CrtDumpMemoryLeaks de sorte que toute la mémoire qu'il a alloué sera libéré et non répertoriés dans les blocs de fuite de mémoire.

    #define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#include <vector>

int main()
{
    {
        std::vector<struct Foo*> listPtrs;
    }

    _CrtDumpMemoryLeaks();

    return 0;
}

    De même si vous appelez _CrtDumpMemoryLeaks après principal a retourné des ressources allouées par std::vector doit être libéré. Là encore, c'est parce que listPtrs a maintenant disparu hors de portée et le destructeur de std::vector a été appelé.

    #define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#include <vector>

//Call _CrtDumpMemoryLeaks after main has returned and before program terminates.
struct AtExit
{
    ~AtExit() { _CrtDumpMemoryLeaks(); }
} doAtExit;

int main()
{
    std::vector<struct Foo*> listPtrs;

    return 0;
}

    Je recommande fortement d'utiliser des pointeurs intelligents au lieu de pointeurs nus. Il les garde au chaud en hiver et vous n'aurez pas à vous soucier d'utiliser delete. 

    #define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#include <vector>
#include <memory>

//Call _CrtDumpMemoryLeaks after main has returned and before program terminates.
struct AtExit
{
    ~AtExit() { _CrtDumpMemoryLeaks(); }
} doAtExit;

int main()
{
    std::vector<std::unique_ptr<struct Foo*>> listPtrs;

    return 0;
}
    +1 Il les garde au chaud en hiver

    OriginalL'auteur Captain Obvlious

  2. 1

    Dans les deux morceaux de code que vous avez attribué votre vector<> sur la pile. En tant que tel, le vecteur est destructeur sera appelé quand elle est hors de portée. Je ne sais pas ce que le détecteur de fuite que vous utilisez, mais si elle vérifie les fuites juste avant les sorties principales, il peut en effet détecter une fuite, mais ce n'est pas vraiment une fuite.

    Où vous obtenez des problèmes avec des fuites de mémoire, c'est que le std::vector destructeur ne vais pas l'appeler delete sur les éléments dans le vecteur, mais il va appeler leurs destructeurs. Ainsi vector<int> et vector<MyClass> sont beaux comme le vecteur contient l'objet et l'appeler le destructeur de. D'autre part, si vous avez vector<MyClass*>, vous devez être prudent; de supprimer le vecteur pas libérer la mémoire associée à la MyClass objets vers lesquels il pointe.

    OriginalL'auteur Oliver Dain