[MALLOC] Pourquoi mon code fonctionne-t-il ? (structures imbriquées)
Bonjour à tous,
(Si ça peut aider je code avec VC++ 2005 et je suis débutant en C).
J'ai donc un gros problème : mon code fonctionne :yaisse2: plus sérieusement, il semble fonctionner mais j'ai dû changer mon raisonnement (pour un que je ne comprends pas) en cours de route.
J'explique vite fait : à la base je comptais créer un tableau dynamique de 3 structures imbriquées dynamiques. N'y arrivant (toujours) pas j'ai tout remis à plat pour le faire étapes par étapes en commençant par allouer & initialiser 2 structures imbriquées (cf. code)
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
//#include "structures.h"
#define TAILLE_MAX 16
#define NB_MAX 4
/* Déclaration des types */
typedef struct Struc_2 Struc_2 ;
struct Struc_2
{
char uneChaine_2[TAILLE_MAX + 1] ;
int unEntier_2 ;
int unAutreEntier_2 ;
} ;
typedef struct Struc_1 Struc_1 ;
struct Struc_1
{
char uneChaine_1[TAILLE_MAX + 1] ;
Struc_2 * lesStruc_2 ;
} ;
/* Programme Principal */
int main (void)
{
int i = 0 ; // indice de boucle
errno_t err = 0 ; // code d'erreur
Struc_1 * uneStruc_1 = NULL ; // Pointeur vers une struct de type Struc_1
// On demande la place en mémoire pour notre struct de type Struc_1
uneStruc_1 = malloc (sizeof (Struc_1)) ;
if (uneStruc_1 == NULL)
{
printf ("\n *** Erreur #1: allocation\n") ;
return EXIT_FAILURE ;
}
// On demande la place en mémoire pour notre tableau de 'sous-struct' de type Struc_2
uneStruc_1->lesStruc_2 = malloc (sizeof (Struc_2) * NB_MAX) ;
if (uneStruc_1->lesStruc_2 == NULL)
{
printf ("\n *** Erreur #2: allocation\n") ;
return EXIT_FAILURE ;
}
//--------- Initialisation de notre structure de données ---------//
// Initialisation de uneStruc_1
err = strcpy_s (uneStruc_1->uneChaine_1,
sizeof (uneStruc_1->uneChaine_1),
"Une chaine 1") ;
if (err != 0)
{
printf ("\n *** Erreur #1: strcpy_s\n") ;
return EXIT_FAILURE ;
}
// Initialisation de uneStruc_2
for (i = 0 ; i < NB_MAX ; i ++)
{
err = strcpy_s (uneStruc_1->lesStruc_2[i].uneChaine_2,
sizeof (uneStruc_1->lesStruc_2[i].uneChaine_2),
"Une chaine 2") ;
if (err != 0)
{
printf ("\n *** Erreur #2: strcpy_s\n") ;
return EXIT_FAILURE ;
}
uneStruc_1->lesStruc_2[i].unEntier_2 = 0 ;
uneStruc_1->lesStruc_2[i].unAutreEntier_2 = 0 ;
}
// Libération de la mémoire
free (uneStruc_1->lesStruc_2) ;
free (uneStruc_1) ;
return EXIT_SUCCESS ;
} |
(J'espère que d'avoir remplacé mes noms de variables par des noms génériques ne le rend pas illisible).
Donc mon 1er raisonnement lors de mes allocations était :
- Avant d'allouer la place en mémoire pour maStruc_1 il faut que je connaisse sa taille.
- Sa taille étant liée à celle de lesStruct_2 (future tableau dynamique de Struc_2 de NB_MAX éléments), il faut d'abord allouer ce tableau de Struc_2.
Maintenant en pratique, avec cet ordre d'allocations, le code compilait mais générait une exception de Windows à l'exécution. Exception que je pressentais même si mon ordre d'allocation me paraissait logique.
Je me suis donc résigné d'aller à l'encontre de mon raisonnement et allouer en première maStruc_1. Dans ma p'tite tête, j'allais allouer sans problèmes maStruc_1 mais avec un espace mémoire juste suffisant pour contenir maChaine_1 et un pointeur Struc_2*. Par conséquent j'allais écraser une zone mémoire avec ma deuxième allocation.
Bon pendant que j'écrivais je me dis que le 2ème raisonnement est logique finalement :oops: ... La 1ère allocation me donne effectivement la place pour seulement une chaine et un pointeur et ce pointeur pointe sur la zone allouée au 2ème malloc() qui n'a pas lieu d'être imbriquée comme la représentation graphique qu'on peut se faire d'une structure imbriquée... oui ?
Bon après ce monologue =) , mes questions :
- Ce code fonctionne-t-il effectivement ou attend t-il qu'on tourne le dos pour planter ? Est-ce-que j'ai fait n'importe quoi ?
- J'ai lu par-ci par-là que la somme des sizeof(données_membres) était pour les uns égale au sizeof(Structure) et pour les autres non... qu'en est-il ?
- Pour créer un tableau dynamique de Struc_1 est-ce-que je vais devoir passer par un tableau de pointeur vers des Struc_1 (Struc_1 ** mesStruc_1) ?
- Mes 2 free() doivent-ils être suivis respectivement de uneStruc_1->lesStruc_2 = NULL ; et uneStruc_1 = NULL ;
Merci de m'éclairer, promis je ferais plus court la prochaine fois ! =)
