Allocation dynamique de structure et organisation de la mémoire

Salut,

J'aurais une question relative à l'allocation dynamique de structures. La réponse est sans doute triviale, mais quelque chose m'échappe :(

Je possède les structures suivantes :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

typedef struct { S_STRUCT2 *ps_struct2; } S_STRUCT;   typedef struct { S_STRUCT3 *ps_struct3; S_STRUCT4 *ps_struct4; } S_STRUCT2;   typedef struct { S_STRUCT5 *ps_struct5; } S_STRUCT3;

---

Et le code suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10

S_STRUCT *ps_struct;   int nb_elements = 2000; int nb_max_points = 1000;   ps_struct->ps_struct2 = (S_STRUCT2 *) malloc(nb_elements * sizeof(S_STRUCT2))); ps_struct->ps_struct2->ps_struct4 = (S_STRUCT4 *) malloc(nb_elements * sizeof(S_STRUCT4))); ps_struct->ps_struct2->ps_struct3 = (S_STRUCT3 *) malloc(nb_elements * sizeof(S_STRUCT3))); ps_struct->ps_struct2->ps_struct3->ps_struct5 = (S_STRUCT5 *) malloc(nb_max_points * sizeof(S_STRUCT5)));

---

J'alloue donc la mémoire qu'il me faut.

Cependant je cherche à savoir comment va s'organiser la mémoire.

En gros j'essaie d'accéder à (ps_struct->ps_struct2 + 1)->ps_struct4 qui s'avère être vide.
Même chose pour (ps_struct->ps_struct2 + 1)->ps_struct3

Par contre quand je fais (ps_struct->ps_struct2->ps_struct4 + 1) j'accède bien à ma structure (toutefois je retrouve le même problème avec ps_struct5 qui ne m'est pas accessible dans ps_struct3.

Je supposais que la mémoire s'organisait de sorte que l'espace mémoire soit réparti entre les différents éléments des structures. Mais apparemment ça ne marche pas comme cela.

Savez-vous s'il y a moyen de répartir la mémoire de sorte que (ps_struct->ps_struct2 + 1)->ps_struct3 par exemple ne soit plus vide mais déjà alloué ? Ou dois-je faire moi même la correspondance entre les éléments du gros bloc alloué et les structures ?

Je ne sais pas si je suis super clair :/ Pas facile de présenter clairement mon problème. Je peux essayer de mieux expliquer si personne n'arrive à comprendre ma question.

Si jamais quelqu'un à une éventuelle piste à mon donner, j'en serais très heureux. J'ai passé ma journée à essayer de comprendre pourquoi j'avais des structures non allouées, et je ne comprends toujours pas d'ailleurs ^^

Un grand merci d'avance

Ton problème n'est effectivement pas très clairement expliqué mais bon.

Le problème est que tu utilises plusieurs malloc().

Malloc te garantie qu'il retourne un bloc de mémoire contigue de la taille demandé (ou une erreur). Par contre rien ne garantie que plusieurs malloc consécutifs retournent des bloc de mémoire contigus.

Pour régler ton problème, il te faut faire un gros malloc (1MO par exemple) et ensuite faire tes propres fonctions d'allocation/libération qui utilisent ce bloc comme tu le souhaites. Par contre, je ne suis pas sûr de l'intérêt de la chose.

[Edit] Autre idée, allouer en une fois (ou avec realloc) un tableau de structures

Merci à toi. Mais effectivement à ta réponse, je pense que je n'ai vraiment pas été clair.
Demain à tête reposée j'essaierai de rendre tout ça plus clair. L'idéal en fait serait de faire un schéma. Un screen de ddd serait sans doute plus approprié :)

Citation:

---

Pour régler ton problème, il te faut faire un gros malloc (1MO par exemple) et ensuite faire tes propres fonctions d'allocation/libération qui utilisent ce bloc comme tu le souhaites. Par contre, je ne suis pas sûr de l'intérêt de la chose.

---

Maintenant je pense que ton idée est sans doute la solution à mon problème.

Maintenant le problème c'est que c'est une fonction qui a déjà été écrite (pas par moi, et déjà utilisée autre part). Elle fonctionne dans d'autres contextes, par conséquent, le problème vient sans doute de moi et de l'utilisation que j'en fait. Cependant cela m'amène tout de même à me poser la question de la répartition de la mémoire.

Je pense que j'ai bien saisi l'idée du fonctionnement du malloc par blocs contiguës.

Je vais quand même essayer d'expliquer mieux. En fait si je fais ça :

Code:

---

1 2	ps_struct->ps_struct2 = (S_STRUCT2 *) malloc(nb_elements * sizeof(S_STRUCT2))); ps_struct->ps_struct2->ps_struct4 = (S_STRUCT4 *) malloc(nb_elements * sizeof(S_STRUCT4)));

---

J'aimerais pouvoir manipuler les pointeurs de la façon suivante:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

S_STRUCT2 *ps_structure; int nb_elements = 2000; int n;   ps_structure = ps_struct->ps_struct2;   for(n=0;n<nb_elements;n++){ printf("Adresse pointeur = %p\n", ps_structure->ps_struct4); // Puis manipuler ps_structure->ps_struct4 à mon aise, changer la valeur de la structure pointée par ps_struct4 etc. ps_structure++; }

---

Mais ça ne fonctionne pas, ps_structure->ps_struct4 n'est pas alloué.
(enfin ça marchera pour le premier tour de boucle, mais pas après)
Par contre, si je fais ça, j'ai accès au pointeur ps_struct4

Code:

---

1 2 3 4 5 6 7 8 9 10 11

S_STRUCT2 *ps_structure; int nb_elements = 2000; int n;   ps_structure = ps_struct->ps_struct2->ps_struct4;   for(n=0;n<nb_elements;n++){ printf("Adresse pointeur = %p\n", ps_structure); ps_structure++; }

---

Si je n'ai pas été super clair encore une fois, la nuit me portera conseil ^^ je renouvellerai demain :P

Merci d'avance quoi qu'il en soit aux gens assez motivés pour essayer de me comprendre ;)

Bonjour,

En principe en C, le type casting du retour de malloc n'est pas recommandé.

Code:

---

1 2	ps_struct->ps_struct2 = malloc(nb_elements * sizeof(S_STRUCT2))); ps_struct->ps_struct2->ps_struct4 = malloc(nb_elements * sizeof(S_STRUCT4)));

---

Donc après exécution de deux lignes, nous avons:

1. ps_struct n'est pas alloué (Comportement indeterminé)
2. ps_struct2 (objet de ps_struct) pointe une zone nb_elements de type S_TRUCT2
3. ps_struct4 (objet de ps_struct2) pointe une zone de nb_elements de S_STRUCT4

Effectivement seul le premier object ps_struct4 est alloué.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

S_STRUCT2 *ps_structure; int nb_elements = 2000; int n;   /* -j0w0- Ton compilateur devrait d'avertir qu'on ne peut pas   assigner le pointeur ps_struct4 à ps_structure de type S_STRUCT2 * */ ps_structure = ps_struct->ps_struct2->ps_struct4;   for(n=0;n<nb_elements;n++){ printf("Adresse pointeur = %p\n", ps_structure); ps_structure++; }

---

Je conseille de revoir la documentation concernant les pointeurs en C.

Citation:

---

Envoyé par jowo

En principe en C, le type casting après malloc n'est pas recommandé.

---

grrr.. qu'on arrête un peu avec ça...

Génial ! Ca marche \o/

Alors, à tête reposée et grace à vos pistes j'ai pu reprendre mon code ce matin, et j'ai trouvé la raison de mon problème.

Initialement je pensais que la mémoire s'organisait d'elle même sur les structures, en répartissant les zones mémoires où il faut. Or, ce n'est pas du tout le cas. (naïf que je suis)

Donc la démarche c'est une allocation d'un bloc avec quelques mallocs (le code que j'ai montré) puis un parsing de chaque structure pour indiquer où commence et où finit l'espace alloué à chaque structure. On alloue donc une fois (au début) la mémoire nécessaire, puis on répartit les zones mémoires dans nos structures, avec une boucle qui va aller faire pointer les pointeurs où il faut dans la mémoire déjà allouée.

Bref, tout cela était bien logique finalement, c'est juste que je m'étais fait une mauvaise visualisation du fonctionnement de l'allocation des structures et de leurs éléments fils.

Donc merci à vous !

Sinon, serait-il possible de savoir pourquoi le casting après malloc n'est pas recommandé ? (ou est-ce un troll ? à la vue de la réaction de souviron34) J'essaie, tant qu'à faire, d'optimiser et rendre mon code le plus propre possible, du coup si c'est déconseillé je peux le retirer, mais j'aimerais tout de même savoir pourquoi.

Merci d'avance :)

Le débat/troll/whatever est ici:
http://www.developpez.net/forums/d50...retour-malloc/

Ah :) merci bien !
Je regarde ça.