Comment gratuit une structure qui contient uniquement des pointeurs

J'ai un struct que vous voyez ci-dessous:

typedef struct _List {
    Person *person; //pointer for people list
    DoList *do; //Kinda timer, for checking list in some intervals
} List;

Sont-il besoin pour libérer de cette structure? Si oui, comment puis-je libre?

Le code que vous avez montré, est une définition de type. Gratuit avec un type ne fait pas de sens sémantique, vous pouvez seulement les instances d'un type, et seulement si ils ont été alloués dynamiquement. En tant que tel, cette question n'a aucun sens. Le fait que la structure contient des pointeurs est irellevant - données sont des données; toutefois, vous aurez besoin de libérer de données que les pointeurs pointent vers avant libération de la structure de l'instance elle-même. La réponse dépend du contexte, et que vous avez fourni aucun contexte.

OriginalL'auteur wonnie | 2011-02-06

  1. 13

    Vous devez libérer la struct si vous avez alloué dynamiquement. Vous avez pour libérer de ses membres avant de la désallocation de la struct si vous avez réservé les membres de manière dynamique et qui n'ont pas de référence de n'importe où d'autre.

    Voici quelques exemples:

    void freeNotRequiredHere() {
List            nonDynamicList;
Person          nonDynamicPerson;
DoList          nonDynamicDoList;
nonDynamicList.person = &nonDynamicPerson;
nonDynamicList.do = &nonDynamicDoList;
}
void freeRequiredForStructListOnly() {
List            *dynamicList;
Person          nonDynamicPerson;
DoList          nonDynamicDoList;
dynamicList = (List *) malloc( sizeof(struct List) );
dynamicList->person = &nonDynamicPerson;
dynamicList->do = &nonDynamicDoList;
free( dynamicList );
}
void freeRequiredForStructListAndPersonOnly() {
List            *dynamicList;
Person          *dynamicPerson;
DoList          nonDynamicDoList;
dynamicList = (List *) malloc( sizeof(struct List) );
dynamicPerson = (Person *) malloc( sizeof(Person) );
dynamicList->person = dynamicPerson;
dynamicList->do = &nonDynamicDoList;
free( dynamicPerson );
free( dynamicList );
}
void freeRequiredForStructListAndPersonOnly( DoList *notSureDoList ) {
List            *dynamicList;
Person          *dynamicPerson;
dynamicList = (List *) malloc( sizeof(struct List) );
dynamicPerson = (Person *) malloc( sizeof(Person) );
dynamicList->person = dynamicPerson;
dynamicList->do = notSureDoList;
//maybe notSureDoList was allocated with malloc(),
//maybe it is a non-dynamic stack variable.
//the calling function should deal with free()'ing notSureDoList
free( dynamicPerson );
free( dynamicList );
}
    Permettez-moi de vous montrer comment j'ai utilisé le malloc: <CODE> Liste *l; l = malloc(sizeof(Liste)); l->personne = personpointer; l->do = add_timer(personpointer, 15); </CODE>
    À partir de votre exemple, oui, vous avez besoin de free() l. Vous devez libérer de l'() tout ce que vous allouer avec malloc(). Avant de vous free (), bien que vous aurez probablement envie de faire l'équivalent de remove_timer() sur l->ne depuis le l et de ses membres (la personne et faire des pointeurs eux-mêmes, et non pas les choses, et ne point) ne seront plus valables après le free().
    Mais l'OP demande "la nécessité de libérer ce?". Et que la réponse dépend de l'objet est nécessaire jusqu'à ce que le programme prévoit exit(2). Si oui, alors il ne pas doivent être libérés. L'OS va le faire, et de le faire beaucoup plus rapidement.
    À partir d'une facilité de maintenance, en particulier si quelqu'un arrive plus tard et copie/colle ou s'étend du code, il est de loin une bonne idée (et la programmation des meilleures pratiques) pour libérer de ce que vous allouer et pas s'appuyer sur exit() pour nettoyer après vous. Votre commentaire n'est pas mal per se, c'est juste pas bien rangé et il y a de bonnes chances d'être paresseux par pas correctement libérant de ce que vous malloc de causer des problèmes pour quelqu'un, quelque part, plus tard. [edit: je vois que vous avez adressée à mon commentaire comme une modification à votre réponse ci-dessous; depuis que cette question est pour les débutants, je vais laisser mon commentaire].

    OriginalL'auteur par

  2. 4

    Si vous avez attribué un objet à l'aide malloc(), alors vous avez besoin de free() à un certain point.

    OriginalL'auteur Oliver Charlesworth

  3. 4
    void free_mystruct(struct_List *a_ptr){
free(a_ptr->person);
free(a_ptr->do);
free(a_ptr);
}

    si vous avez utilisé la fonction malloc pour d'abord allouer de la mémoire.

    OriginalL'auteur ayush

  4. 4

    Ça dépend...

    Vous a demandé "...tout besoin de...?" et la réponse est "ça dépend".

    • Si la structure est nécessaire presque jusqu'à ce que le programme se termine par un retour de main(), exit(), ou d'un signal, puis pas il ne doit jamais être libéré, indépendamment de ce qu'il est.1

    • Si la ressource est allouée de manière dynamique dans un long terme de processus comme un éditeur ou un démon du serveur, mais si après la transaction ou de la période de temps qu'il n'est plus nécessaire, alors oui, elle n'a besoin d'être libéré ou, le programme aura une fuite de mémoire.

    • Libérant la structure va se produire une fuite de mémoire si les objets contenus sont également alloués dynamiquement. Soit rien du tout doit être libéré ou la totalité du graphe d'objets avec une racine à cette structure devra être libéré.

    La règle est simple, chaque individu malloc() doit correspondre à une seule personne free().

    1. Disant cela attire généralement une petite inondation de doctrinaires "vous devez libérer de tout" de protestation, mais cette contestation est en partie mal informés. Le C++ Faq traite la question. Seul souci, c'est que c'est lent et inutile de page ou de toucher beaucoup de pages que l'OS est en mesure de le libérer comme un bloc. Mais oui, il y a un argument que c'est un bon motif de conception, de bonnes pratiques, et s'il y a possibilité d'intégrer le code dans un deuxième programme, alors la mémoire doit être libérée toujours.

    OriginalL'auteur DigitalRoss