Problème de Pointeur avec une structure pointée

Version imprimable

Bonjour :)

Voila, dans le but de mes cours, je dois essayer de faire de l'allocation dynamique d'un pointeur sur une structure pointée... enfin si je m'exprime bien :)

Voici le 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
 
 
// Pointeur Structure.cpp*: définit le point d'entrée pour l'application console.
//
 
#include "stdafx.h"
#include <stdlib.h>
#include <string.h>
 
#define MAX 2
 
 
typedef struct personne
{
 char nom[40];
 char sexe;
 int age;
 
} ELEVE;
 
void ajouterEleve (ELEVE **, int *);
void afficherEleve (ELEVE **, int *);
 
 
int _tmain(int argc, _TCHAR* argv[])
{
	 ELEVE ** ptab_eleve=NULL,*p;
	 char nomT [40];
	 char **pnomT;
 
 
	int taille=1,i=0;
 
 //ajouterEleve(ptab_eleve,&taille);
 
// printf("\n taille: %d\n",taille);
	ptab_eleve=(ELEVE**) malloc(sizeof (ELEVE));
	p=(ELEVE*) malloc(sizeof (ELEVE));
	strcpy(p->nom,"gaston");
	if( ptab_eleve == NULL )
{
     printf("Allocation impossible");
}
	strcpy((*(ptab_eleve)+i)->nom, p->nom); /* Voila mon problème car je ne sais pas comment je dois faire pour accéder au paramètre nom de ma structure ELEVE avec ptab_eleve*/
 
 
 
 
// afficherEleve (ptab_eleve,&taille);
 
 
/* for (i=0;i<taille;i++)
 {
     free(ptab_eleve[i]);
     
 } */
 
	return 0;
}

si quelqu'un pouvait éclairer ma lanterne, ce sera sympa car la, je cale :(

Merci pour votre aide :)

26/01/2012, 22h18
diogene
Si je comprend (?), il faut un tableau d'ELEVE alloué par allocation dynamique. Celle-ci va renvoyer l'adresse du premier élément du tableau alloué, soit un type ELEVE*
Code:

1 2 ELEVE * ptab = malloc(N* sizeof *ptab); if(ptab!= NULL)...
où N est le nombre d'ELEVE dans le tableau

Les différents ELEVE du tableau sont accessible par ptab[i] et leur nom par ptab[i].nom (i=0..N-1)

Code:

strcpy(ptab[i].nom,"gaston");
26/01/2012, 23h45
misterlagaffe

heu... à la base dans mon code, j'ai ELEVE ** ptab_eleve = NULL;

quand je lis l'exemple que tu donnes, il n'y est plus... mon code serait il si mauvais :-s

car oui, je dois allouer mon tableau de manière dynamique d'ou une double étoile :)
27/01/2012, 01h49
Bousk
Non c'est la "première étoile" qui indique qu'il s'agit d'un pointeur, et que tu souhaites utiliser comme tableau.
La seconde étoile indique que son contenu sera des ELEVE*

Et dans ton cas, l'utilisation d'un pointeur sur pointeur, la double étoile, traduit un manque de connaissance des pointeurs, vu l'utilisation que tu souhaites. Un tableau dynamique d'objet te suffira. Sinon, tu devras aussi allouer chaque ELEVE* contenu dans celui-ci.

D'ailleurs,
Code:

1 2 ELEVE** ptab_eleve=(ELEVE**) malloc(sizeof (ELEVE)); ELEVE* p=(ELEVE*) malloc(sizeof (ELEVE));
tu alloues 2 variables qui n'ont pas le même type avec la même taille.
Rien ne te choque ?
27/01/2012, 08h21
misterlagaffe
Mince, au départ, j'avais mis ceci :
Code:

1 2 3 ELEVE** ptab_eleve=(ELEVE**) malloc(sizeof (ELEVE*)); ELEVE* p=(ELEVE*) malloc(sizeof (ELEVE));
mais je supose que cela ne change pas grand chose...

sinon pour répondre à la question pourquoi une double étoie, c'est mon prof qui me l'a demandé :/

car par la suite, je dois utiliser la fonction realloc pour agrandir dynamiquement mon tableau de pointeurs.

Citation:

Envoyé par misterlagaffe

mais je supose que cela ne change pas grand chose...

Dans ce code, tu n'alloues qu'un seul pointeur dans ton tableau de pointeur ptab_eleve.

Et si ce dernier exemple que tu donne change parceque il y a une différence entre sizeof(ELEVE) et sizeof(ELEVE *). L'un te donne la taille d'une structure élève, l'autre te donne la taille d'un pointeur vers une telle structure.

Citation:

Envoyé par Bousk

Un tableau dynamique d'objet te suffira

C'est peut-être un exercice pédagogique pour apprendre les pointeurs de pointeurs.

Si tu veux donc travailler avec un tableau de pointeur il faut plutot faire un truc comme cela :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 /* allocation de ton tableau de pointeurs */ ptab_eleve = (ELEVE**) malloc(N * sizeof (ELEVE *)); if(ptab_eleve == NULL) { printf("Allocation impossible"); } /* allocation d'un eleve */ p = (ELEVE*) malloc(sizeof (ELEVE)); if(p == NULL) { printf("Allocation impossible"); } /* renseignement des champs de la structure élève */ strcpy(p->nom,"gaston"); p->age = 12; /* etc */ /* on met l'élève dans le tableau par une simple affectation de pointeur. */ /* i < N */ ptab_eleve[i] = p;

Effectivement, c'est bien çà Valefor :)
mais helas, quand j'applique çà avec une fonction, l'affichage ne fonctionne mais bon, je pense qu'un exemple vaut mieux que du blabla :-)

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
77
// Pointeur Structure.cpp*: définit le point d'entrée pour l'application console.
//
 
#include "stdafx.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define MAX 2
 
 
typedef struct personne
{
	char nom[40];
	char sexe;
	int age;
 
} ELEVE;
 
void ajouterEleve (ELEVE **, int *);
void afficherEleve (ELEVE **, int *);
 
 
int _tmain(int argc, _TCHAR* argv[])
{
	ELEVE ** ptab_eleve=NULL,*p;
 
 
 
	int taille=1,i=0;
 
	ajouterEleve(ptab_eleve,&taille);
 
	printf("(main)nom : %s\n", ptab_eleve[i]->nom); // Ca plante
 
 
	return 0;
}
 
void ajouterEleve (ELEVE ** ptab, int *nb)
{
	int i=0;
	char reponse;
	ELEVE *p;
 
 
		/* allocation de ton tableau de pointeurs */
		ptab = (ELEVE**) malloc(5 * sizeof (ELEVE *));
		if(ptab == NULL)
		{
			printf("Allocation impossible");
		}
 
		/* allocation d'un eleve */
		p = (ELEVE*) malloc(sizeof (ELEVE));
		if(p == NULL)
		{
			printf("Allocation impossible");
		}
		/* renseignement des champs de la structure élève */
		strcpy(p->nom,"gaston");
		p->age = 12;
		/* etc */
 
		/* on met l'élève dans le tableau par une simple affectation de pointeur. */
		/* i < N */
		ptab[i] = p;		
		printf("--------------------------------------------------------\n");
 
		printf("(fonction)nom: %s\n",ptab[i]->nom);
 
		free(p);
 
 
 
 
}

Apparemment, d'après les échanges précédents, on te demanderait de faire un tableau de pointeurs sur ELEVE qui devrait être redimensionné si nécessaire. Je me demande si ce n'est pas plutôt un tableau d'ELEVE au vu du prototype de ajouterEleve() que tu envisages. Je vais toutefois faire une description pour un tableau de pointeurs, elle est facilement adaptable en cas de tableau d'ELEVE.

L'adresse du début du tableau de pointeurs sera donc placée dans une variable du type ELEVE** .
L'ajout d'un ELEVE dans ce tableau se fera par :
1- si le tableau possède une case vide (un pointeur NULL) alors ajouter le nouvel ELEVE à cette place
2- si toutes les cases sont utilisées, agrandir le tableau et ajouter le nouvel ELEVE.
   Attention cette opération peut modifier l'adresse de départ du tableau de pointeurs et modifie son nombre d'éléments.
la fonction ajouterEleve() doit donc connaitre :
- l'adresse du premier élément du tableau (de pointeurs)
- le nombre actuel d'éléments de ce tableau (nécessaire pour faire le redimensionnement)
- l'adresse de l'ELEVE à ajouter au tableau 
elle doit pouvoir modifier
- l'adresse du premier élément du tableau de pointeurs en cas de redimensionnement
- le nombre d'éléments de ce tableau en cas de redimensionnement
ses paramètres sont donc
- l'adresse du pointeur (contenant l'adresse du premier élément du tableau) pour pouvoir modifier le pointeur
- l'adresse de l'entier (contenant le nombre d'éléments) pour pouvoir modifier sa valeur
- l'adresse de l'ELEVE à ajouter au tableau
elle peut avantageusement renvoyer un indicateur indiquant que l'insertion a réussi ou échoué (reallocation réussie ou en échec)

Son prototype serait alors

Code:

int ajouterEleve( ELEVE *** tab, int * n, ELEVE * eleve);

Elle serait appelée de la façon suivante
Code:

1 2 3 4 ELEVE ** tableau = NULL; int ntab = 0; // création d'un ELEVE à l'adresse p : p = malloc(sizeof(ELEVE); + initialisation if (!ajouterEleve(&tableau,&ntab,p) printf("Erreur d'allocation");
Le déroulement de la fonction int ajouterEleve(ELEVE *** tab,int *n, ELEVE * eleve) :
-  Chercher si il y a une place libre dans le tableau débutant en *tab et ayant *n éléments :
    Chercher de i = 0 à i < *n si il y a un pointeur NULL dans le tableau.
-  Si oui, mettre eleve à cette place, retourner 1
-  Si non, agrandir le tableau de N (>0) cases (realloc()).
     -  En cas d'échec retourner 0
     -  En cas de succès 
          - mettre eleve en *n et mettre à NULL les pointeurs de *n+1 à *n+N-1
          - Copier la nouvelle valeur du nombre d'éléments *n+N dans *n
          - Copier la nouvelle adresse de départ du tableau dans *tab
          - retourner 1

N'ayant pas l'énonce complet, on ne peut que faire des suppositions, mais diogene a totalement raison.

Par contre, pour le code en lui-même, il y a des lacunes.

Dans ton main

Code:

ajouterEleve(ptab_eleve,&taille);

ptab_eleve est NULL à ce moment-là. Attention à ce que ça peut entraîner.

Ensuite, et plus grave amha
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 void ajouterEleve (ELEVE ** ptab, int *nb) { int i=0; char reponse; ELEVE *p; /* allocation de ton tableau de pointeurs */ ptab = (ELEVE**) malloc(5 * sizeof (ELEVE *)); if(ptab == NULL) { printf("Allocation impossible"); } /* allocation d'un eleve */ p = (ELEVE*) malloc(sizeof (ELEVE)); if(p == NULL) { printf("Allocation impossible"); } /* renseignement des champs de la structure élève */ strcpy(p->nom,"gaston"); p->age = 12; /* etc */ /* on met l'élève dans le tableau par une simple affectation de pointeur. */ /* i < N */ ptab[i] = p; printf("--------------------------------------------------------\n"); printf("(fonction)nom: %s\n",ptab[i]->nom); free(p); }
Tu commences par allouer ptab avec 5 cases, potentiellement tu perds ce qu'il contenait auparavant : fuite mémoire.
puis tu crées un ELEVE* que tu places en ptab[0]; 2° source de fuite mémoire : tu perds l'ancien contenu de ptab[0]

Commencer par réviser son cours sur les pointeurs semble être une bonne idée;).
Pars d'un code plus simple, et complexifie-le au fur et à mesure.:ccool:

Effectivement j'ai du mal à le maitriser ce pointeur de pointeur. Avec un pointeur simple, je n'ai pas trop de soucis mais là, j'avoue, je suis perdu.

en fait, j'ai fait cette exercice de manière simple à la base.

Cela ressemble à ca : Attention: je n'ai fait aucune vérification, c'est juste savoir utiliser les structures qu'on nous demande.
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 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX 3 typedef struct personne { char nom[40]; char sexe; int age; } ELEVE; int main(int argc, char *argv[]) { ELEVE toto [MAX]; int i=0; for (i=0;i<MAX;i++) { printf("Eleve N : %d\n",i+1); printf("Veuillez introduire un nom svp? "); gets(toto[i].nom); fflush(stdin); printf("Veuillez introduire le sexe de l'eleve : "); scanf("%c",&toto[i].sexe); fflush(stdin); printf("Veuillez introduire l'age de l'eleve : "); scanf("%d",&toto[i].age); fflush(stdin); printf("--------------------------------------------------------\n"); } system ("CLS"); for (i=0;i<MAX;i++) { printf("Eleve N : %d\n",i+1); printf("Nom: %s\n",toto[i].nom); printf("Sexe: %c\n",toto[i].sexe); printf("Age : %d\n",toto[i].age); printf("----------------------\n"); } system("PAUSE"); return 0; }
ah oui, je vais remplacer le fflush (stdin) car j'ai lu que ce n'était pas bon pour vider le tampon dans la FAQ :)

Oui, j'ai mis 5 pour effectuer un test sinon, par défaut, c'est 1.

Par contre, quand tu me dis qu'il y a un risque de fuite de mémoire car ma valeur vaut NULL, que dois je faite pour ne pas rencontrer ce type de probleme.

Je parle pour cette ligne de code :

Code:

ajouterEleve(ptab_eleve,&taille);

Merci pour tout votre réponse :):ccool:

27/01/2012, 14h19
Bousk

La fuite n'est pas dûe au simple NULL en entrée.
Une fonction AjouterEleve, j'attends d'elle qu'elle ajoute un eleve à ma liste. La tienne se charge aussi de créer la liste (admettons, pourquoi pas), sans aucune vérification quant à l'existence ou pas préalable de la liste.
Si ta liste existe déjà, y'a fuite.
Apelle-la 2 fois, y'aura une fuite.
27/01/2012, 15h17
misterlagaffe

donc, si je comprends bien ton raisonnement, je dois faire une condition pour vérifier que mon pointeur vaut bien NULL avant d'appeler ma fonction ajouter si celui-ci n'est pas vide, je dois lever une exception :)
27/01/2012, 16h13
diogene

Repars sur des bases neuves et saines. Là tu perds ton temps à rafistoler un bout de code bricolé.
Je t'ai donné une trame pour te permettre de faire un code correct. Si il te manque des explications, pose des questions.

Hello :-)

je reviens à la charge avec ces pointeurs :-)

Voila un premier jet qui contourne ceci : ELEVE ***ptab_eleve.

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define VIDE fflush(stdin)
/*
 * Tableau dynamique de pointeurs vers des élèves alloués dynamiquement
 */
typedef struct eleve {
    char nom[40];
    char sexe ;
    int age ;
} ELEVE ;
 
ELEVE **ajouter (ELEVE **ptab, int *pn) ;
void afficher (ELEVE **ptab, int n) ;
int question(void) ;
void encoder_eleve(ELEVE *) ;
void afficher_eleve(ELEVE *) ;
 
void libere_mem(ELEVE **ptab, int n) ;
 
int main(int argc, char** argv) {
    ELEVE **ptab_eleve ;
    int nb_eleve ;
 
    ptab_eleve = NULL ;
    nb_eleve = 0 ;
 
    ptab_eleve = ajouter(ptab_eleve, &nb_eleve);
    afficher(ptab_eleve, nb_eleve);
 
    libere_mem(ptab_eleve,nb_eleve) ;
    return (EXIT_SUCCESS);
}
int question()
{
   char reponse[254] ;
   strcpy(reponse,"O");
   printf ("\nVoulez_vous ajouter un eleve?") ;
   gets(reponse) ;
   if (!strcmp(reponse,"O") || !strcmp(reponse,"o"))
     return 1 ;
   else
     return 0 ;
 
}
void encoder_eleve(ELEVE *peleve){
   printf("\nNom:");
   gets(peleve->nom) ;
   printf("\nSexe:") ;
   scanf("%c",&(peleve->sexe));
   VIDE ;
   printf("\nAge:") ;
   scanf("%d",&(peleve->age));
   VIDE ;
}
ELEVE **ajouter(ELEVE **ptab, int *pn)
{
   ELEVE *peleve ;
   int nb_eleve ;
 
   nb_eleve = *pn ;
 
   while (question())
   {
     ptab = (ELEVE **)realloc(ptab,(nb_eleve+1) * sizeof(ELEVE *)) ;
 
     peleve = (ELEVE *)malloc(sizeof(ELEVE)) ;
     encoder_eleve(peleve) ;
 
     *(ptab+nb_eleve) = peleve ;
 
     nb_eleve++ ;
 
   }
 
   *pn = nb_eleve ;
   return ptab ;
}
 
void afficher_eleve(ELEVE *pel)
{
        printf("\nNom: %s", pel->nom);
        printf("\nSexe: %c", pel->sexe) ;
        printf("\nAge: %d", pel->age) ;
}
 
void afficher (ELEVE **ptab, int n) {
    int i ;
 
    printf("\n:%d: eleve(s)",n);
    for (i = 0; i < n; i++)
    {
        afficher_eleve(*(ptab+i)) ;
        printf("\n") ;
    }
 
}
 
void libere_mem(ELEVE **ptab, int n)
{
    int i ;
 
    for (i = 0; i < n; i++)
    {
       free(*(ptab+i)) ;
    }
    free (ptab) ;
}

Ce code fonctionne :)

Maintenant, j'essaie de refaire çà avec mes ***ptab_eleve :-)

Citation:

Envoyé par diogene

Son prototype serait alors

Code:

int ajouterEleve( ELEVE *** tab, int * n, ELEVE * eleve);

Elle serait appelée de la façon suivante

Code:

1
2
3
4
ELEVE ** tableau = NULL;
int ntab = 0;
// création d'un ELEVE à l'adresse p : p = malloc(sizeof(ELEVE); + initialisation
if (!ajouterEleve(&tableau,&ntab,p) printf("Erreur d'allocation");

Ca ok, j'ai compris :-)

Citation:

Envoyé par diogene

Le déroulement de la fonction int ajouterEleve(ELEVE *** tab,int *n, ELEVE * eleve) :

-  Chercher si il y a une place libre dans le tableau débutant en *tab et ayant *n éléments :
    Chercher de i = 0 à i < *n si il y a un pointeur NULL dans le tableau.
-  Si oui, mettre eleve à cette place, retourner 1

Toujours ok, pas de soucis de compréhension.

Citation:

Envoyé par diogene

-  Si non, agrandir le tableau de N (>0) cases (realloc()).
     -  En cas d'échec retourner 0
     -  En cas de succès 
          - mettre eleve en *n et mettre à NULL les pointeurs de *n+1 à *n+N-1
          - Copier la nouvelle valeur du nombre d'éléments *n+N dans *n
          - Copier la nouvelle adresse de départ du tableau dans *tab
          - retourner 1

Là par contre, çà coince :(

Je m'explique, le realloc, ca fonctionne (enfin je l’espère)... par contre pour l'affectation et l'affichage de données... ça plante :/

Je montre mon ébauche de code. si on pouvait me dire ou ca coince car j'ai tout essayé et zéro. La compil fonctionne sans erreur mais l’exécution, il flanche :/

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
 
// Pointeur Structure.cpp*: définit le point d'entrée pour l'application console.
//
 
#include "stdafx.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
 
#define VIDE fflush(stdin)
 
 
typedef struct personne
{
	char nom[40];
	/*char sexe;
	int age;*/
 
} ELEVE;
 
void ajouterEleve (ELEVE ***, int *);
void afficherEleve (ELEVE **, int *);
 
 
int _tmain(int argc, _TCHAR* argv[])
{
	ELEVE ** ptab_eleve=NULL,*p;
 
 
 
	int taille=0,i=0;
 
	ajouterEleve(&ptab_eleve,&taille);	
 
	return 0;
}
 
void ajouterEleve (ELEVE *** ptab, int *nb)
{
	int i=0;
	char reponse;
	ELEVE *p;
 
	p = (ELEVE*) malloc (sizeof (ELEVE));
	if(p == NULL)
		{
			printf("Allocation impossible");
		}
	ptab =  (ELEVE ***) realloc (*(ptab),(*nb+1)*sizeof (ELEVE **));
	if(ptab == NULL)
		{
			printf("Allocation impossible");
		}
	printf("\nVeuillez introduire le nom de l'eleve : ");
	gets(p->nom);
	VIDE;	
        *(*(ptab)+i) = p; // Il plante
 
	//printf("\n Nom : %s\n", (**(ptab+i))->nom);
}

02/02/2012, 12h08
diogene
1- on ne doit pas utiliser fflush() sur un flux d'entrée comme stdin. Le résultat est dépendant de l'implémentation (ne marche pas toujours). Voir la FAQ pour savoir comment vider le buffer d'entrée.

2- ne pas utiliser gets() mais fgets() sur stdin

3- Ce code ne correspond pas à la trame évoquée plus haut.
- *nb n'est pas mis à jour
- le nouveau pointeur ne doit pas être mis à l'index i (=0), mais en queue du nouveau tableau

4- Plus grave :
le realloc est incorrect :

Code:

ptab = (ELEVE ***) realloc (*(ptab),(*nb+1)*sizeof (ELEVE **));

ptab contient l'adresse du début du tableau de pointeurs. Il ne faut pas le modifier. Ce qu'il faut modifier, c'est le début du tableau et on devrait avoir

Code:

*ptab= realloc(*ptab, (*nb+1)sizeof (ELEVE *))

Il faut tenir compte de l'échec du realloc() et éviter dans ce cas une fuite mémoire par perte de l'adresse de l'ancien tableau. Le schéma doit être le suivant :
Code:

1 2 3 4 5 6 7 8 p = realloc(*ptab,...) if(p == NULL) { // echec, on peut libérer la mémoire précédemment allouée par free(*ptab) } else // succès { *ptab = p; // suite du traitement
02/02/2012, 13h43
misterlagaffe

ah zut... et moi qui pensait etre dans le bon avec mon realloc :/

enfin j'ai corrigé ce que tu m'a conseillé mais le *pat dans ton exemple ca correspond à quoi ?

Par déduction, je suppose que c'est

ELEVE **pat mais suis je dans le bon ? :-s

car on en revient au problème d'affectation que j'ai depuis le debut :(

Merci pour ton aide :-)
02/02/2012, 16h22
diogene

Citation:

enfin j'ai corrigé ce que tu m'a conseillé mais le *pat dans ton exemple ca correspond à quoi ?

A une erreur de frappe, il s'agit de ptab
Je corrige mon post.

ouch... la je ne te suis plus du tout...

si je comprends bien ce qu'il faut faire.

Je fais un realloc pour ptab et p comme suit :
Code:

1 2 3 4 5 6 7 8 9 10 11 *ptab= realloc(*ptab, (*nb+1)sizeof (ELEVE *)); p = realloc(*ptab,...) if(p == NULL) { // echec, on peut libérer la mémoire précédemment allouée par free(*ptab) } else // succès { *ptab = p; // suite du traitement
si j'essaie de comprendre, je dirais que la dernière ligne est une assignation mais peut être que je fais fausse route.. mais si c'est ainsi, ca ne va, j'ai une erreur d'assignation. :(

02/02/2012, 19h00
diogene

Faut pas tout mélanger :

La ligne 2 du code que tu postes fait une reallocation qui entrainerait une fuite de mémoire en cas d'échec

La suite du code (lignes 4 à 11) fait une reallocation qui peut tenir compte de l'échec

OK... c'est bien ce que je pensais !

par contre cette ligne la et ce quelque soit le compilateur, elle est refusée:

*Ptab = p //erreur d'assignation

si je fais par contre ceci :

**ptab = p, pas d'erreur à la compil mais il plante à l’exécution, ce qui est logique :?

donc je me suis dit que j'allais faire ceci :
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 ajouterEleve (ELEVE *** ptab, int *nb) { int i; char reponse; ELEVE *p, **pat; i= *nb; p = realloc (*ptab, (i+1)*sizeof (ELEVE)); if (p==NULL) { printf("\n probleme d'allocation de memoire\n"); free (*ptab); } else { printf("\nVeuillez introduire le nom SVP : "); fgets (p->nom,sizeof p->nom, stdin); viderBuffer(); *(pat+i) =p; *ptab = pat; i++; } *nb = i; }
Ceci fontionne pour ajouter UN élève, dès qu'il y en a DEUX ou plus, le programme accepte mais quand je fais appel à mon fonction pour afficher les données, ca plante.

Au cas ou, voilà mes fonctions pour afficher les données :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 void afficher (ELEVE *pel) { printf("\nNom: %s", pel->nom); /*printf("\nSexe: %c", pel->sexe) ; printf("\nAge: %d", pel->age) ;*/ } void afficherEleve (ELEVE **ptab, int n) { int i ; printf("\n:%d: eleve(s)",n); for (i = 0; i < n; i++) { afficher (*(ptab+i)) ; printf("\ni: %d", i) ; } }

02/02/2012, 19h47
diogene

Il faut se décider : tu fais un tableau d'ELEVE ou un tableau de pointeurs sur ELEVE, parce que ton code mélange les deux : la déclaration de la fonction penche pour la deuxième solution et le corps de la fonction plutôt vers la première

Alors, décide et informe nous de ta décision, parce que là, on perd notre temps
02/02/2012, 19h59
misterlagaffe

c'est bon ca fonctionne...

Désolé de te faire perdre ton temps mais sache que j'ai écouté les conseils mais qu'hélas cette ligne :

Code:

*ptab = p

ne fonctionne pas :(

alors oui, je dois certainement mélanger les deux mais comme tout débutant qui a des faiblesses et qui patauge avec les pointeurs, il faut que je fasse des erreurs de manip, que j'essaie des choses pour progresser...

et pour répondre à la question, c'est un pointeur de pointeurs de tableau mais comme mon professeur me le dit: joué avec des pointeurs, ce n'est pas toujours évidemment mais il faut bien passer par là pour les maitriser par la suite.

Bonne soirée :)

@misterlagaffe

tu dois réfléchir à ce qui crée la confusion dans ta pensée. tu n'es pas le seul dans ce cas. tout le monde est passé par là. en C, l'origine du problème est que les pointeurs viennent très tôt, comme en assembleur. voici un petit bout de code qui devrait te faire voir la différence entre un pointeur (une variable) et une adresse (une valeur).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include <stdio.h> char p[1]; //p est le symbole d'une adresse fixée par le compilateur char * q; //q est le symbole d'une variable pouvant contenir une adresse int main(void){ puts("on peut distinguer les adresses des variables :"); printf("adresse :\n %p -> %p (valeurs identiques)\n", &p, p); q = p; printf("variable contenant une adresse :\n %p -> %p (valeurs differentes)\n", &q, q); return 0; } exécution : on peut distinguer les adresses des variables adresse : 00402170 -> 00402170 (valeurs identiques) variable contenant une adresse : 00402174 -> 00402170 (valeurs differentes)
p n'est pas une variable. c'est simplement le symbole d'une adresse.
q est une variable dont le contenu est une adresse.

nb. j'ai connu des compilateurs qui utilisent des pointeurs pour stocker les adresses, même quand elles sont calculables à la compilation mais je n'en ai pas sous la main...

Si c'est un tableau de pointeurs qui est construit, alors les éléments sont des pointeurs sur ELEVE : ELEVE *
L'adresse du premier élément de ce tableau est du type "Adresse d'un ELEVE *" soit ELEVE**.

L'allocation de ce tableau est alors suivant le modèle
Code:

1 2 ELEVE **p; p = realloc (*ptab, (i+1)*sizeof (ELEVE *));
Ceci va créer de la place pour un pointeur sur ELEVE, mais ne va pas créer l'ELEVE.
Il faut donc aussi créer un ELEVE, mettre les informations dedans, et mettre son adresse dans la case nouvellement allouée du tableau
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 if (p==NULL) { ... } else { *ptab = p; // Créer un ELEVE et mettre son adresse dans le tableau p[i] = malloc(sizeof(ELEVE)); if(p[i] != NULL) { // initialiser le nouvel ELEVE .... }

03/02/2012, 09h17
misterlagaffe

Merci à vous pour toutes vos réponses :-)

Effectivement, Diogone, j'ai relu mon petit script et j'ai pris cette voie la par la suite. Du coup, ca m'a fait plaisir en voyant ta proposition sur ton dernier message car j'avais écrit la meme chose :-)

Bon hé bien , je peux mettre, enfin, cette discussion comme résolue et compter le nombre de cheveux qu'il me reste sur ma tête :mouarf: