C++ casté realloc provoquant la fuite de mémoire

Question

J'utilise une fonction que j'ai trouvé here pour enregistrer une page Web à la mémoire avec cURL:

struct WebpageData { 
    char *pageData; 
    size_t size; 
}; 

size_t storePage(void *input, size_t size, size_t nmemb, void *output) { 
    size_t realsize = size * nmemb; 

    struct WebpageData *page = (struct WebpageData *)output; 

    page->pageData = (char *)realloc(page->pageData, page->size + realsize + 1); 
    if(page->pageData) { 
     memcpy(&(page->pageData[page->size]), input, realsize); 
     page->size += realsize; 
     page->pageData[page->size] = 0; 
    } 

    return realsize; 
} 

et trouvez la ligne:

page->pageData = (char *)realloc(page->pageData, page->size + realsize + 1); 

est à l'origine une mémoire fuite de quelques centaines d'octets par appel. Le seul vrai changement que j'ai fait de la source originale est de lancer la ligne en question à un (char *), que mon compilateur (gcc, g ++ spécifiquement si c'est un problème ac/C++, mais gcc ne compilerait pas non plus déclaration) insisté sur, mais je suppose que c'est la source de la fuite. Quelqu'un peut-il élucider?

Merci

Answer 1

Le code que vous avez posté (autant que je sache) est correct. Si elle fuit, je suppose que vous oubliez free() le bloc de mémoire à un moment donné. realloc est autorisé à créer un nouveau bloc de mémoire entier s'il ne peut pas simplement agrandir le existant, et cela vous intéresse. Il est également possible d'allouer un bloc plus grand que nécessaire, ce qui peut entraîner des fuites fantômes. Maintenant, puisque vous utilisez C++, je dois demander: pourquoi n'utilisez-vous pas std::vector à la place?

struct WebpageData { 
    std::vector<char> pageData; 
    size_t size; 
}; 

size_t storePage(void *input, size_t size, size_t nmemb, void *output) { 
    size_t realsize = size * nmemb; 
    WebpageData *page = reinterpret_cast<WebpageData *>(output); 

    page->pageData.resize(page->size + realsize + 1); 
    memcpy(&(page->pageData[page->size]), input, realsize); 
    page->size += realsize; 
    page->pageData[page->size] = 0; 

    return realsize; 
} 

Answer 2

Si le développement sur * nix j'en général essayer d'exécuter le programme avec valgrind (http://valgrind.org/) pour une fuite de mémoire problèmes Realted (dans ce cas, je pense que vous ne savez où la mémoire est affectée, mais où est-il en train d'être libéré?). Dans ce cas, je suggérerais de ne pas utiliser malloc, realloc et toute autre gestion de mémoire c similaire dans un programme C++ à moins que cela ne soit absolument nécessaire et inévitable. Ils devraient être évités en faveur de l'utilisation des outils de gestion de la mémoire C++, dans ce cas je pense que la mémoire n'est pas libérée correctement. L'utilisation de vecteurs C++ vous facilitera probablement la vie car vous n'aurez pas à vous soucier du redimensionnement de la matrice et du suivi de tous les changements dans l'allocation de mémoire.

Answer 3

La distribution ne doit pas faire de différence avec realloc. Êtes-vous sûr d'avoir une fuite de mémoire? Le code ajoute les données, donc si vous le demandez à stocker trois fois avec 1kB de données à chaque fois, il stockera 3kB. Est-ce ce que vous vouliez quand vous avez copié et collé le code? Et bien sûr vous devez libérer() le bloc quelque part quand vous en avez fini avec.

Autres pensées:

• sont les mémoire que vous reallocing à l'origine malloc'd ou realloc'd?

• Notez que si vous ne parvenez pas à réaffecter les données, vous perdrez tout. Si vous réalisez un pointeur temporaire et que vous remplacez simplement page-> pageData si elle est valide, cela ne se produira pas, et vous serez en mesure de signaler l'échec à l'appelant (bien que cela soit très improbable en pratique, et vous aurez probablement beaucoup plus de problèmes si c'est le cas!)

• Vous réallouez le bloc chaque fois que vous recevez de nouvelles données. Il sera probablement plus efficace d'allouer un bloc plus grand que nécessaire, de récupérer les données dans celui-ci, puis de les réaffecter dans un bloc exact uniquement après avoir reçu toutes les données, de façon à éviter de réallouer le bloc à plusieurs reprises.