Erreur de segmentation lors de l’access à une liste dans une structure

Je vais essayer de clarifier les choses.

Voici ma structure:

struct scopeList{ int id; list internal_list; }; typedef struct scopeList scopeList_T; 

Voici le code qui me donne la segmentation.

 int main(){ scopeList_T* t1 = (scopeList_T*) malloc(sizeof(scopeList_T)); t1->id = 5; //works fine t1->internal_list.push_front(5); //segmentation fault } 

Puisque j’alloue de la mémoire et que j’accède à id, c’est bien, pourquoi cela me donne-t-il une erreur de segmentation? Dois-je faire quelque chose de spécial à la liste en premier?

Merci!

Utilisez new au lieu de malloc !

 sopeList_T* t1 = new scopeList_T; 

malloc n’exécute aucun constructeur. Lorsque vous devez libérer cette struct , utilisez delete plutôt que free – vous ne pouvez pas free objects alloués avec new (et free n’appelle pas les destructeurs).

Vous n’avez pas besoin non plus de ce typedef, la déclaration de struct suffit.

 struct scopeList { int id; list internal_list; }; int main() { scopeList *t = new scopeList; .... delete t; .... } 

Vous n’initialisez pas la liste à l’aide d’un constructeur, ce qui laisse des données non valides à la position de internal_list.

Les bonnes réponses ont été données ci-dessus: Vous avez alloué la mémoire de votre structure mais n’avez exécuté aucun constructeur pour les sous-objects qui sont dans un état non initialisé. Je dois insister: c’est un no-go absolu. NE JAMAIS mélanger les appels à alloc & Co. avec du code C ++.

Puisque malloc n’appelle pas le constructeur, vous devez utiliser l’une des deux méthodes suivantes:

  1. Utilisez new pour allouer la mémoire ainsi que la construction de l’object:

     sopeList_T* t1 = new scopeList_T;//it allocates and then call the ctor! //use delete to deallocate the memory delete t1; 
  2. Ou utilisez malloc pour allouer la mémoire que vous êtes déjà en train de faire et utilisez le placement new pour construire l’object:

     scopeList_T* t1 = (scopeList_T*) malloc(sizeof(scopeList_T)); //allocation t1 = new (t1) scopeList_T; //it calls the ctor //use free to deallocate the memory t1->~scopeList_T(); //call the destructor explicitly - necessary! free(t1); 

Allouer de la mémoire ne suffit pas. Vous devez également appeler le constructeur.

La méthode la plus courante et recommandée d’allocation dynamic simple en C ++ est la suivante:

 scopeList_T* t1 = new scopeList_T; 

est alloue de la mémoire et appelle ensuite constuctor.

Une fois que vous avez fini avec la structure, vous devez supprimer l’object comme ceci

 delete t1; 

AJOUTER:

Si vous avez vraiment besoin d’utiliser un autre allocateur de mémoire (comme malloc / free ou quelque chose de votre propre conception), vous devez alors allouer de la mémoire et appeler le nouvel emplacement (c’est comme si vous appeliez explicitement le constituant). Lorsque vous en avez terminé avec l’object, vous devez appeler le destructeur explicitement, puis libérer la mémoire. Ce qui est important: la mémoire allouée pour l’object doit répondre aux exigences d’alignement pour ce type d’object.

Exemple:

 // allocating memory void* p = my_alloc( sizeof(scopeList_T) ); if( p == NULL ) { // report allocation error and throw or return } // placement new operator scopeList_T* t1 = new(p) scopeList_T; // t1 == p // do some thing with the object // ............................. // call destructor explicitly t1->~scopeList_T(); // free memory my_free(p); // or free(t1); that is the same