free() sur tableau dynamiques à 4 dimensions

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : free() sur tableau dynamiques à 4 dimensions

cheetwoox

Salut,
J'ai un leger problème avec du code que j'ai tapé
Le programme fait ce qu'il faut, mais plante à la fin, à la libération de la mémoire !

Je met un exemple de la création du tableau 4 dimensions et de sa libération, si quelqu'un veux bien regarder ce qui cloche, ce serait très sympa :
J'ai légerement modifié pour que vous ayez une taille si vous voulez tester. Ceci crée un tableau w[10][3][2][2] qu'on peut utiliser comme un tableau 4 dimensions classiques (ex : w[0][0][0][0]=1.0.

Code :

double ****w;
w = (double****)malloc(10*sizeof(double));
for (i=0; i<10; i++){
w[i] = (double***)malloc(3*sizeof(double));
for (j=0; j<3; j++){
w[i][j] = (double**)malloc(2*sizeof(double));
for (k=0; k<2; k++){
w[i][j][k] = (double*)malloc(2*sizeof(double));
}
}
}
for (i=0; i<10; i++){
for (j=0; j<3; j++){
for (k=0; k<2; k++){
free(w[i][j][k]);
}
free(w[i][j]);
}
free(w[i]);
}
free(w);

Il y a plusieurs tableaux de ce genre dans le code (1,2,3 ou 4 dimensions). Or il semblerait qu'il plante la dessus mais aléatoirement (des fois il plante sur un autre free()).
Si je vire la partie de libération mémoire, mon programme marche nickel, mais j'ai peur que ca pose des problèmes de pas libérer la mémoire ?

Merci de votre aide.

Message cité 1 fois

Publicité

Sve@r

D'une façon générale, il est très rare qu'on dépasse "**" en dimensions car après, on arrive plus à bien visualiser.
Mais le pb vient des malloc initiaux.

cheetwoox a écrit :

Code :

double ****w;
w = (double****)malloc(10*sizeof(double));

"w" est un "double étoile étoile étoile étoile" donc à l'adresse pointée par "w" (qu'on peut nommer "w[0]" ou "*w" ), on a un "double étoile étoile étoile". Et toi, tu veux allouer 10 valeurs de ce type donc le bon malloc est

Code :

double ****w
w = (double ****)malloc(10*sizeof(double ***));

Idem pour les autres malloc. A chaque sous-niveau, tu supprimes une étoile...

Sinon, l'enchainement des free est correct.

Autre chose: Si les tailles à allouer sont toujours constantes, tu peux te passer des malloc et des free

Code :

double w[10][3][2][2];

Message cité 1 fois
Message édité par Sve@r le 26-08-2006 à 18:39:21

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

cheetwoox

Ok, genial j'avais pas fait attention à cette erreur ^^.
Pour les tailles elles ne sont malheureusement pas fixes...
Merci beaucoup je vais essayer ça !

Emmanuel Delahaye

C is a sharp tool

Sve@r a écrit :

D'une façon générale, il est très rare qu'on dépasse "**" en dimensions car après, on arrive plus à bien visualiser.
Mais le pb vient des malloc initiaux.

"w" est un "double étoile étoile étoile étoile" donc à l'adresse pointée par "w" (qu'on peut nommer "w[0]" ou "*w" ), on a un "double étoile étoile étoile". Et toi, tu veux allouer 10 valeurs de ce type donc le bon malloc est

Code :

double ****w
w = (double ****)malloc(10*sizeof(double ***));

C'est pour çà (entre autres), qu'on préfère l'écriture :

Code :

double ****w = malloc (nb_t * sizeof *w);

C'est beaucoup plus clair... ensuite :

Code :

w[i] = malloc (nb_z * sizeof *w[i]);
...
w[i][j] = malloc (nb_y * sizeof *w[i][j]);
...
w[i][j][k] = malloc (nb_x * sizeof *w[i][j][k]);

avec, ici, si j'ai bien compris,

nb_x = 2
nb_y = 2
nb_z = 3
nb_t = 10 ...

Message édité par Emmanuel Delahaye le 26-08-2006 à 21:28:29

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/

cheetwoox

Je connaissais pas cette écriture, ça condense plutôt bien et c'est bien lisible, je vais l'essayer (et surement l'adopter) Mais il faut quant même les boucles car on alloue de l'espace dans chaque case ?

Sinon il semble qu'il n'est pas possible d'allouer un tableau dynamique dans un sous programme si on veut l'utiliser dans un programme principal car j'ai essayé de passer ****w a un sous programme et d'allouer, mais ensuite ca ne fonctionne pas dans le programme principal si je veux l'utiliser. Idem pour la libération mémoire.

En fait ce serait pour faire plus propre dans le programme principal en plaçant les nombreuses lignes dans un sous programme.

Message cité 1 fois

cheetwoox

J'ai écrit ça mais il plante toujours sur la libération :

Code :

double ****w;
w = (double****)malloc(nbNrLig*sizeof(double***));
for (i=0; i<nbNrLig; i++){
w[i] = (double***)malloc(nbColNr*sizeof(double**));
for (j=0; j<nbColNr; j++){
w[i][j] = (double**)malloc(2*sizeof(double*));
for (k=0; k<2; k++){
w[i][j][k] = (double*)malloc(2*sizeof(double));
}
}
}
for (i=0; i<nbNrLig; i++){
for (j=0; j<nbColNr; j++){
for (k=0; k<2; k++){
free(w[i][j][k]);
}
free(w[i][j]);
}
free(w[i]);
}
free(w);

J'ai fait une erreur ?

Message cité 1 fois

Emmanuel Delahaye

C is a sharp tool

cheetwoox a écrit :

Oui, bien sûr, je n'ai mis que l'essentiel...

Citation :

Sinon il semble qu'il n'est pas possible d'allouer un tableau dynamique dans un sous programme si on veut l'utiliser dans un programme principal car j'ai essayé de passer ****w a un sous programme et d'allouer, mais ensuite ca ne fonctionne pas dans le programme principal si je veux l'utiliser. Idem pour la libération mémoire.

Bien sûr que si. Le plus simple est de retourner une adresse de type T****.
(T étant le type que utilises, int, je crois...)

Citation :

En fait ce serait pour faire plus propre dans le programme principal en plaçant les nombreuses lignes dans un sous programme.

Absolument, il est même fortement recommandé de faire comme ça. Entraine toi sur un tableau à 1 ou 2 dimensions. Commencer par 4 dimensions sans connaître certaines bases du C, c'est un peu casse-gueule...

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/

Emmanuel Delahaye

C is a sharp tool

cheetwoox a écrit :

J'ai écrit ça mais il plante toujours sur la libération :

Ton code est correct. Comment tu sais que ça plante ? Il se passe quoi ?

Ceci fonctionne et dispose de plus de contrôles :

Code :

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
size_t const nbNrLig = 4;
size_t const nbColNr = 3;
size_t i;
double ****w = malloc(nbNrLig * sizeof * w);
if (w != NULL)
{
for (i = 0; i < nbNrLig; i++)
{
size_t j;
w[i] = malloc(nbColNr * sizeof * w[i]);
if (w[i] != NULL)
{
for (j = 0; j < nbColNr; j++)
{
size_t k;
w[i][j] = malloc(2 * sizeof * w[i][j]);
if (w[i][j] != NULL)
{
for (k = 0; k < 2; k++)
{
w[i][j][k] = malloc(2 * sizeof * w[i][j][k]);
}
}
}
}
}
}
for (i = 0; i < nbNrLig; i++)
{
size_t j;
for (j = 0; j < nbColNr; j++)
{
size_t k;
for (k = 0; k < 2; k++)
{
free(w[i][j][k]);
}
free(w[i][j]);
}
free(w[i]);
}
free(w);
return 0;
}

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/

cheetwoox

C'est du code C compilé via Matlab, ça compile bien mais si j'affiche des textes au millieu des free(), je remarque que le programme s'arrete par là. Si je vire les free() tout passe nickel et fonctionne bien, pas de plantage
Se pourrait il que Matlab ait un peu de mal avec du code qui serait pourtant bon ?
En tout cas je vais essayer de déporter tout ça dans un sous programme pour voir.
Merci de votre aide.

Message cité 1 fois

Emmanuel Delahaye

C is a sharp tool

cheetwoox a écrit :

J'ai toujours pas compris quel était le plantage.

Dans tout les cas, il faut vérifier si il n'y a pas de débordement du tableau.

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/

Publicité

cheetwoox

Il plante bien sur les free().
Mais il y en a plusieurs vu qu'il y a pas mal de tableaux.
Or il plante parfois sur l'un, parfois sur l'autre (mais toujours des free) !

Que se passe t'il si je ne libère pas la mémoire et que je lance ce programme plusieurs milliers de fois (le système ne la libèrera pas tout seul ?) ?

J'ai essayé ça pour déporter la création et suppression de mémoire :

Code :

#include <stdlib.h>
#include <stdio.h>
void creerC(int *c);
void deleteC(int *c);
int main()
{
int *c;
creerC(c);
c[0] = 1;
printf("%d\n",c[0]);
system("PAUSE" );
deleteC(c);
return 0;
}
void creerC(int *c)
{
c = (int*)malloc(10*sizeof(int));
}
void deleteC(int *c)
{
free(c);
}

Ceci ne fonctionne pas (la fenêtre ne reste pas ouverte alors qu'elle le devrait). J'imagine que ce code est completement faux ?

Message cité 1 fois

Emmanuel Delahaye

C is a sharp tool

cheetwoox a écrit :

Ben au bout d'un moment, plus de mémoire. C'est pas génant pour un programme 'batch' ou d'usage court ou peu fréquent (le système récupère la mémoire à la fin de l'exécution). C'est évidemment catastrophique pour une application longue (système, service, serveur...)

Citation :

J'ai essayé ça pour déporter la création et suppression de mémoire :

Code :

void creerC(int *c)
{
c = (int*)malloc(10*sizeof(int));
}

Ceci ne fonctionne pas (la fenêtre ne reste pas ouverte alors qu'elle le devrait). J'imagine que ce code est completement faux ?

Ben sûr que ça ne fonctione pas. Tu modifies la valeur d'un paramètre, ce qui ne sert à rien (et révèle souvent, comme ici, une erreur de conception de l'interface). Il faut retourner la valeur comme le fait malloc(). Et supprimme tous ces casts inutiles (et j'ai montré une autre façon de faire l'allocation, indépendante du type)...

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/

nargy

Il y a une alternative à int****. C'est int*.
Bien que int**** soit correct, et même si c'est pas très lisible, corresponde exactement à ce que tu veux représenter, tu peut allouer un seul bloc de mémoire plûtot qu'une multitude.

Celà permet d'une part de rendre le programme plus lisible et résistant au niveau des allocations/désallocations, et d'autre part de prendre moins de place mémoire et d'être plus rapide.

Par exemple pour un tableau à deux dimensions:

Code :

typedef int* Tableau2D;
Tableau2D alloc2D(unsigned int d1, unsigned int d2)
{ return (Tableau2D)malloc(d1*d2*sizeof(int)); }
void free2D(Tableau2D tab)
{ free(tab); }

Par contre pour acceder au membres du tableau tu doit jongler avec les coordonnées:

Code :

inline int* acces2D(Tableau2D tab, unsigned int x, unsigned int y, unsigned int d1)
{ return tab+x+y*d1; }

Au final le code est plus propre, et à cause de l'architecture de la mémoire des ordinateurs celà reste plus rapide et économique. Tu peut aussi ajouter les contrôles de débordement si necessaire dans la fonction acces2D.

Accès à un tableau 4D:

Code :

inline int* acces4D(Tableau4D tab,
unsigned int x, unsigned int y, unsigned int z, unsigned int t,
unsigned int d1, unsigned int d2, unsigned int d3)
{ return tab+x+(y+(z+t*d3)*d2)*d1; }

el muchacho

Comfortably Numb

Et ça évite (comme ça m'est arrivé l'an dernier) de voir des stagiaires débarquer dans ton bureau avec la question suivante: "comment je fais pour passer un ***p dans une fonction qui n'accepte que des **p ?"...

J'ai été incapable d'expliquer. [:benou] La prochaine fois, je filerai le numéro d'Emmanuel Delahaye.

Message édité par el muchacho le 30-08-2006 à 23:42:32

FORUM HardWare.fr

Programmation

free() sur tableau dynamiques à 4 dimensions

Sujets relatifs
Tableau pour Windows media player ?	[RESOLU] Tableau php, multi colonne?
[RESOLU] recherche sql, tableau php	cosinus des données d'un tableau
Tableau et formulaire mise en forme	realloc d'un tableau plus petit
EXCEL VBA - Bug pour affecter valeurs dans tableau	insérer un tableau dans un richtextbox
Div avec un Overflow hidden dans un tableau.	Comment centrer un tableau au centre de la page?
Plus de sujets relatifs à : free() sur tableau dynamiques à 4 dimensions

Page générée en 0.093 secondes