declaration dynamique dans une fonction

Si je declare dans un programme:

Code:

---

1 2 3 4 5 6 7

typedef struct { int **matriceF; int *info; int *coding; int *MC; }bloc;

---

et que j'alloue la memoire de chacun des pointeurs dans une fonction

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

void compute_bloc (int *info, int j ,int *tailles) { int i,longueur_bloc; bloc bc;   longueur_bloc = (int) tailles[0]/tailles[3]; //initialisation bc.info bc.info = malloc (sizeof(int) * longueur_bloc); if (bc.info == NULL) printf("probleme lors de l'allocation de bc.info\n"); for (i=0;i<longueur_bloc;i++) { bc.info[i] = info[tailles[3]*i + j]; }     bc.matriceF = malloc (sizeof( int *) * longueur); if(bc.matriceF==NULL) { // Gestion de l'erreur } for (i=0;i<longueur;i++) { bc.matriceF[i] = malloc (sizeof( int ) * largeur); if(bc.matriceF[i]==NULL) { // Gestion de l'erreur } }

---

est ce que une fois revenu dans le programme principal je peux lire
par exemple bc.matriceF[k]
sans risque que les donnees ont ete effacées????

Une fois revenu dans le programme principal, bc n'existe plus car tu declares bc en de type bloc en variable locale.

A la sortie de ta fonction, bc sera detruit (mais pas tout ce que tu as alloue entre temps qui sera zombi dans la memoire).

Si tu veux pouvoir garder la main sur ta structure, declare bloc* bc, malloc bc, et return bc.

Tu pourras alors acceder a tes donnees.

Ton programme est inpécable, il manque un petit détail , c'est que tu as déclaré la variable bc dans le corps de la fonction , donc tu vas perdres le pointeur vers la matrice une fois que tu as quitté cette fonction, pour résoudre le problème voici le code qu'il faut mettre :

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

void compute_bloc (int *info, int j ,int *tailles,bloc * bc) { int i,longueur_bloc;   longueur_bloc = (int) tailles[0]/tailles[3]; //initialisation bc.info bc->info = malloc (sizeof(int) * longueur_bloc); if (bc->info == NULL) printf("probleme lors de l'allocation de bc.info\n"); for (i=0;i<longueur_bloc;i++) { bc->info[i] = info[tailles[3]*i + j]; }     bc->matriceF = malloc (sizeof( int *) * longueur); if(bc->matriceF==NULL) { // Gestion de l'erreur } for (i=0;i<longueur;i++) { bc->matriceF[i] = malloc (sizeof( int ) * largeur); if(bc->matriceF[i]==NULL) { // Gestion de l'erreur } }

---

en suite pour appeler la fonction il faut déclarer la variable bc ailleur, et passer la variable par adresse avec l'opérateur & .

une autre solution est de déclarer

Code:

---

bloc bc

---

dans ton programme principal, et de passer un pointeur vers bc comme paramètre de ta fonction:

Code:

---

void compute_bloc (int *info, int j ,int *tailles, bloc *pBc);

---

(quand tu appelles ta fonction, tu passes l'adresse de bc:)

Code:

---

&bc

---

ensuite, ta fonction reste la même. Mais il faut changer les

Code:

---

bc.blablabla

---

par des

Code:

---

pBc->blablabla

---

puisqu'on manipule un pointeur vers un bloc et non plus bloc.


EDIT: Argh! j'ai été trop lent!

je récapitule, je déclare mes fonctions et ma structure:

Code:

---

1 2 3 4 5 6 7 8 9

void compute_F(int*, int, struct *); void computeFD(int,int *, struct *); typedef struct { int **matriceF; int *info; int *coding; int *MC; }bloc;

---

Dans le main je déclare *bc:

Code:

---

bloc *bc;

---

lors de l'appel de fonction, j'ai :

Code:

---

1 2	compute_F(tailles, NW, &bc); computeFD(NW, tailles, &bc);

---

Avec cette configuration j'ai aucune erreur du compilateur par contre j'ai des warning:
formal parameter 3 different from declaration
warning C4047: 'function' : 'struct $S3 *' differs in levels of indirection from 'struct bloc ** '
'computeFD' : different types for formal and actual parameter 3

et bien souvent les warning annoncent des problemes.....

Citation:

---

Envoyé par gronaze

je récapitule, je déclare mes fonctions et ma structure:

Code:

---

1 2 3 4 5 6 7 8 9

void compute_F(int*, int, struct *); void computeFD(int,int *, struct *); typedef struct { int **matriceF; int *info; int *coding; int *MC; }bloc;

---

Dans le main je déclare *bc:

Code:

---

bloc *bc;

---

---

Personne ne t'a dis de faire ça, mais plutôt :

1 - définir le type de la structure :

Code:

---

1 2 3 4 5 6 7 8 9

typedef struct { int **matriceF; int *info; int *coding; int *MC; } bloc_s;

---

2 - définir les prototypes des fonctions :

Code:

---

1 2 3

void compute_F(int*, int, bloc_s *); void computeFD(int,int *, bloc_s *);

---

Nota : 1 et 2 sont placés dans un header (.h) en cas de compilation séparée

3 - dans l'application (main, par exemple) inclure le header precédemment décrit si necessaire, définir une instance de la structure et passer son adresse aux fonctions:

Code:

---

1 2 3 4 5 6 7 8 9 10

{ bloc_s bc; int x; int y;   compute_F(&x, 456, &bc); computeFD(789, &y, &bc);   }

---

Juste une remarque sur ce qui a été dis précédement

Et si je ne m'abuse, Process Linux à dis :

Citation:

---

Ton programme est inpécable

---

Code:

---

1 2 3 4 5 6

if (bc->info == NULL) printf("probleme lors de l'allocation de bc.info\n"); for (i=0;i<longueur_bloc;i++) { bc->info[i] = info[tailles[3]*i + j]; }

---

J'ai une petite remarque a emettre : le programme n'est pas si impec que cela ... (en tout cas pour moi ...) En fait, tu fais ton malloc et s'il plantes, tu le signales mais aussitôt après, tu fais comme si tout c'était bien déroulé, c'est embêtant. Le mieux, c'est de ne pas effectuer les opérations pour éviter les plantages (soit tu quittes le programme, soit tu gère celà autrement, ...)

De plus, lorsque ça va planter (et ça va planter, cf Murphy ...), tu ne le saura pas au bon moment, ceci étant du au printf qui est bufferisé. La meilleure solution consiste à effectuer un fprintf sur la sortie d'erreur (stderr), du coup, c'est non buffurisé et celà correspond comme le nom l'indique à une sortie d'erreur, ce qui correspond bien au sujet.

Sinon, pour le reste, rien à rajouter à ce qui a été dis

ok merci.
C'est vrai que c'est mieux d'utiliser un header.

:lol: :lol: