Libérer de la mémoire en utilisant free() whoes pointeur est à l'intérieur d'un pointeur pointant vers la structure

Question

Hey! Je sais que le titre de la question est très effrayant mais je ne suis toujours pas en mesure d'exprimer le problème en une seule ligne!

Voici donc je vais:

Il y a un pointeur de données dire DataPtr qui pointe vers une mémoire allouée dynamiquement et une autre structure pointeur dire StructPtr qui pointe également à une structure allouée dynamiquement.

Et Ces deux sont dans une autre structure, disons OuterStructure.

Il existe une liste liée contenant un pointeur vers une structure externe.

struct StructONE 
{ 
    int a; 
    char b; 
    float c; 
}; 

struct InnerStruct 
{ 
    char a; 
    int b; 
}; 

struct StructTWO 
{ 
    int Num; 
    char * DataPtr; 
    struct InnerStruct * StructPtr; 
}; 

struct LinkList 
{ 
    int NodeNum; 
    int NodeType;  /* To Indicate Whether Pointer is of StructOne or StructTwo */ 
    void * Ptr;  /* This can be of type StructONE or StructTWO */ 
    struct LinkList * Next; 

}; 

LinkList * Start; 
void main() 
{ 

    /* Structure Declarations */ 
    InnerStruct * InnerStructure; 
    StructONE * OneStruct; 
    StructTWO * TwoStruct; 

/* Fill up all the Structure */ 
    InnerStructure= (InnerStruct *)calloc(100,sizeof(InnerStruct)); 
    InnerStructure->a='a'; 
    InnerStructure->b=5; 

    OneStruct= (StructONE *)calloc(100,sizeof(StructONE)); 
    TwoStruct= (StructTWO *)calloc(100,sizeof(StructTWO)); 

    TwoStruct->Dataptr=(char *) calloc(10,sizeof(char)); 
    TwoStruct->StructPtr= InnerStructure; 



/* Add these to Linked List 
    void Add_to_Linked_List(int NodeNum,int NodeType,void *ptr) 
*/ 
    Add_to_Linked_List(1,1,OneStruct); 
    Add_to_Linked_List(2,2,TwoStruct); 

/* Everything is Okey Till Here. 
    Now When I want to delete a node from linked list, 
    First I have to release Memory pointed by DataPtr and StructPtr. */ 

    DeleteNode(1); 

} /* End of Main */ 

Le code pour DeleteNode est comme ceci:

Que dois-je faire ??

Je sais que j'ai écrit du code terriblement ... mais je dois écrire ce complexe beaucoup !! :(

Merci d'avoir lu aussi bien !!

Answer 1

#define STRUCT_ONE 1 
#define STRUCT_TWO 2 

struct LinkList 
{ 
    int NodeNum; 
    int NodeType; 
    union 
    { 
     StructONE * Ptr_One; 
     StructTWO * Ptr_Two; 
    }; 

}; 

................ 

    if(NodePtr->NodeType==STRUCT_ONE) 
    { 
     free(NodePtr->Ptr_One); 
     TempNode->Next=NodePtr->Next; 
     free(NodePtr); 
     return; 
    } 
    else 
    { 
     free(NodePtr->Ptr_Two->DataPtr); 
     .... 
    } 

Answer 2

free((NodePtr->ptr)->DataPtr); 

d'abord, il est vrai que votre code est terrible. Deuxièmement, vous ne disposez pas d'un membre ptr. Vous avez un membre Ptr. Et celui-ci est vide *, donc si vous voulez obtenir DataPtr sortir, vous devez utiliser un casting

free(((struct StructTwo*)(NodePtr->Ptr))->DataPtr); 

Answer 3

vous devez jeter le bon type

/* I like parenthesis :-) */ 
((struct StructTwo *)(NodePtr->ptr))->DataPtr 

Answer 4

Vous devez jeter:

if(NodePtr->NodeType==1) /* Pointer is StructONE Type */ 
{ 
     .... 
} 
else 
{ 
    struct StructTwo * s2ptr; 
    s2ptr = (struct StructTwo *)NodePtr->ptr; 
    free(s2ptr->DataPtr); 
    free(s2ptr->StructPtr); 
    free(NodePtr); 
    } 

Si vous utilisez le pointeur plus d'une fois, déclarant une variable pour le maintenir évite de faire la coulée de type sur chaque ligne.