Discussion :

[macdack]

Bonjour tout le monde , j'ai un petit projet a faire qui consiste a implementer un tableau de structure de la maniere suivante :

1 - Declarer la structure pour presenter un nouveau type appelé Etudiant.

2 - Ecrire la fonction inscrire qui modifie les valeurs des champs d'un étudiant passant par le clavier.

3 - Declarer un tableau de N etudiant .

4- Ecrire la fonction inscription qui appele la fonction inscrire pour chaque Etudiant et l'insert dans ce tableau .

5 - Affichage tu tableau pour confirmer le resultat .

Bon j'ai commencé a codé mais j'ai eu des problemes au niveau de l'allocation en memoire du tableau de structures et surtout comment utiliser le resultat de la fonction inscrire pour l'inserer au tableau .

LE CODE :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <conio.h>
#define N 4
typedef struct {
int code;
char nom;
char prenom;
}Etudiant;
Etudiant tab[N];
inscrire () {
Etudiant *p;
printf("REMPLIR LA STRUCTURE ETUDIANT\n");
p=(Etudiant*)malloc(sizeof(Etudiant));
scanf("%d%s%s",&p->code,&p->nom,&p->prenom);
printf("\nINSCRIRE RESULTAT : \n%d\t%s\t%s",p->code,&p->nom,&p->prenom);
free(p);
}
inscription () {
int i;
Etudiant * tab;
tab = malloc( N * sizeof(Etudiant));
for (i=0;i<N;i++){
    printf("\n-------- ETUDIANT NUMERO %d\t", i );
    inscrire();
    Etudiant *p;
    tab[i].code=p->code;
    tab[i].nom=p->nom;
    tab[i].prenom=p->prenom;
}
for (i=0;i<N;i++) {
    printf("\n le tableau %d : est %d \t %s \t %s",i,tab[i].code,tab[i].nom,tab[i].prenom);
}
free(tab);
}
 
int main (){
inscription () ;
return 0;
}

Merci .

[ternel]

Commence par le début: une bonne présentation de ton code.

• utilise une indentation correcte.
• commente ton code
• regroupe ce qui va ensemble: le type Etudiant et sa manipulation, le tableau et sa manipulation, main.
• N'hésite pas à séparer déclaration et définition.

Ensuite, compile ton code, avec un compilateur moderne:
une fonction doit avoir un type de retour, qui peut être void.

Tu n'es pas obligé de passer par des pointeurs pour les structures.
p est un mauvais nom de variable (surtout pour un pointeur d'étudiant)

Avec ces deux conseils, sans changer ta logique, voici comment tu devrais écrire inscrire():

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
void inscrire () {
	Etudiant etudiant;
	printf("REMPLIR LA STRUCTURE ETUDIANT\n");
 
	scanf("%d %s %s",&p->code,&p->nom,&p->prenom);
	printf("\nINSCRIRE RESULTAT : \n%d\t%s\t%s",&p.code,&p.nom,&p.prenom);
}

une chaine de caractère n'est pas un char, mais un char[] (ou un char*, mais il faut l'allouer et le libérer)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
#define NAME_SIZE 40
typedef struct Etudiant{
	int code;
	char nom[NAME_SIZE];
	char prenom[NAME_SIZE];
} Etudiant;

Voici une réécriture de ton code pour qu'il soit un peu plus propre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
/* je suis persuadé qu'il faut revoir cette liste d'include */
#include <stdio.h>
#include <conio.h>
 
/* ici prochainement, un commentaire qui dira ce que ce programme est censé faire. */
/*
	<nom du fichier>:
	point d'entrée du programme, contient le main.
*/
 
 
/* le type étudiant */
 
typedef struct {
	int code;
	char nom;
	char prenom;
} Etudiant;
 
/* ici prochainement, un commentaire qui dira ce que la fonction fait. */
void inscrire();
 
/* la logique du programme */
 
#define N 4
Etudiant etudiants[N];
 
/* ici prochainement, un commentaire qui dira ce que la fonction fait. */
void inscription ();
 
 
int main (){
	inscription () ;
	return 0;
}
 
/* les définitions des fonctions: */
 
/* vios comment je reprends les memes commentaires de section que plus haut.*/
 
/* le type étudiant */
 
void inscrire() {
	Etudiant etudiant;
	printf("REMPLIR LA STRUCTURE ETUDIANT\n");
	scanf("%d %s %s",&p->code,&p->nom,&p->prenom);
	printf("\nINSCRIRE RESULTAT : \n%d\t%s\t%s",&p.code,&p.nom,&p.prenom);
}
 
/* la logique du programme */
 
void inscription () {
	int i;
	/*
		etudiants est une variable globale, que tu vas utiliser.
		C'est mal, tu devrais utiliser les arguments.
	*/
	for (i=0; i<N; i++){
		printf("\n-------- ETUDIANT NUMERO %d\t", i );
		inscrire();
		Etudiant *p;//et comment le remplis-tu, cet étudiant?
 
		/*
			p étant un pointeur non initialisé, ceci VA causer une segmentation fault.
		*/
		etudiants[i].code=p->code;
		etudiants[i].nom=p->nom;
		etudiants[i].prenom=p->prenom;
	}
 
	/* pas mal comme affichage, mais je rajoute une phrase d'introduction */
	printf("Voici la liste des étudiants: \n");
	for (i=0; i<N; i++) {
		printf("\t[%d]\t%4d\t%s\t%s", i, etudiants[i].code, etudiants[i].nom, etudiants[i].prenom);
	}
}

Je n'ai corrigé que les trois erreurs flagrantes: le pointeur inutile, la confusion char et char[], et le type de retour des fonctions.
Pour la logique, il faudra que tu poses des questions précises.

Mon avis? lis bien l'énoncé, tu n'es pas vraiment dedans.

[macdack]

Merci pour votre réponse je reconnais les erreurs que j'avais passer sous mon code c'est deja pas mal car je commence a zero donc .. merci autre fois .
je vais expliquer d'avantage ou est mon problème .

je reprends le code en corrigeant les erreurs remarqué :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
#define Name_size 30
#define N 5

/* PROGRAMME GESTION DES NOTES DES ETUDIANTS */

/*la structure Etudiant */

typedef struct {
int code ;
char nom[Name_size];
char prenom[Name_size];
}Etudiant;

/* Un Tbealeau de N Etudiants */

Etudiant etudiants[N];

/* La fonction Inscrire qui remplis les champs de la strcuture Etudiant - données saisies au clavier */

void inscrire();

/*la fonction Inscription _ Appelle la fonction inscrire pour chasue etudiant et l'insert au tableau etudiant [N]*/

void inscription ();

/* Le main () */
int main (){
	inscription () ;
	return 0;
}

/* les définitions des fonctions: */


void inscrire() {
	Etudiant etudiant ;
	printf("REMPLIR LA STRUCTURE ETUDIANT\n");
	scanf("%d %s %s",&etudiant.code,&etudiant.nom,&etudiant.prenom);
	printf("\nINSCRIRE RESULTAT : \n%d\t%s\t%s",etudiant.code,etudiant.nom,etudiant.prenom);
}

void inscription () {
	int i;
	
      /*Allocation de la memoire pour le tableau etudiant*/

	for (i=0; i<N; i++){
		printf("\n-------- ETUDIANT NUMERO %d\t", i );
		
       /*  appeler a inscrire() pour remplir la strcuture etudiant */

		inscrire();

       /*inserer la structure remplis par inscrire dans le tableau etudiants*/
	}

	/* affichage */

	printf("Voici la liste des étudiants: \n");
	for (i=0; i<N; i++) {
		printf("\t[%d]\t%4d\t%s\t%s", i, etudiants[i].code, etudiants[i].nom, etudiants[i].prenom);
	}
}

Bon , Voila un autre essaie plus clair de ce que je voulais faire donc pour etre precis :

la fonction inscrire() doit retourner une structure étudiant qu'on a remplis pour l'insérer au tableau ?

comment on fait pour insérer une structure dans un tableau de structure ?( sans oublier l'allocation memoire )

Merci encore une fois ..

[ternel]

La mémoire est utilisable de deux manières.

Dans la pile (stack), quand tu ne fais rien de particulier: les déclarations de variables
Dans le tas (heap), quand tu utilises malloc et free.

La solution simple est la plus conseillée.

En l'occurence, tu veux une fonction qui demande à l'utilisateur un étudiant.
tu as deux possibilités, selon que l'emplacement existe déjà ou non.

Si tu veux créer un étudiant, la fonction doit ressembler à ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Etudiant inscription() {
    Etudiant etudiant;
    //du code qui remplit les champs de étudiant, similaire à ce que tu as fais
    return etudiant;
}

Quand cette fonction est exécutée, elle crée une variable locale, la remplit, et la retourne à l'appeleur.

Si tu veux une fonction qui remplit une variable Etudiant, ca ressemblera à ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void inscription(Etudiant * etudiant) {
    //du code qui remplit les champs de étudiant, similaire à ce que tu as fais
}

Elle sera appelée avec l'adresse d'un étudiant, par exemple inscription(& etudiants[6]);.


En fait, si tu regardes bien, ton problème vient de ce que tu as mélangé plusieurs taches dans une seule fonction:
ta version de inscription:

1. crée une variable étudiant
2. demande à l'utilisateur de quoi la remplir
3. affiche cette variable
4. détruit cette variable

Dans ta première version, tu passais meme par un pointeur pour le faire.

chaque point devrait correspondre à une fonction ou une instruction.

1. déclarer une variable (ou un tableau...)
2. la fonction inscription qu'on t'a demandé
3. une autre fonction, pas explicitement demandée: montrer_etudiant(Etudiant) (avec un pointeur, eventuellement)
4. rien, parce que la destruction d'une simple variable (ou tableau) est automatique.

Je t'invite à visiter notre faq, il y a beaucoup de choses qui pourrait t'être utiles.