Exercice de prog

Question

Bonjour,

Voila mon code, seulement je n'arrive pas a comprendre pourquoi il ne fonctionne pas. Donc est-ce que vous pourriez me le corriger. MERCI : )
La liste à gérer doit être de type « Pile ».

#include<string.h>
#include<stdio.h>
#include<stdlib.h>

/*//////////////////////////////////////////////////////////

FONCTIONS

//////////////////////////////////////////////////////////*/

//definition de la structure

typedef struct piece a; //Structure decrivant une piece

struct PIECE
{
char id[45]; //Désignation de la pièce (45 lettres au plus),
int prix; //prix
int codint[5]; //Son Code interne (5 lettres au plus),
int stock; //quantité en stock
a * PP; //pointeur sur une la piece d'avant
};

//Fonction de creation de piece.

void CREA(a *P)
{
printf("Entrez le nom de la piece correspondante,SVP\n");
fflush(stdin);
scanf("%s", &P->id);

printf("Entrez le prix de la piece correspondante,SVP\n");
fflush(stdin);
scanf("%d", &P->prix);

printf("Entrez le code interne de la piece correspondante,SVP\n");
fflush(stdin);
scanf("%s", &P->codint);

printf("Entrez la quantite correspondante,SVP\n");
fflush(stdin);
scanf("%d", &P->stock);
}

void CREALIFO(pii * P,a * TL)
{
if(&TL->prix!=NULL)
{
P->PP=*TL;
}
else
{
P->PP=NULL;
}
TL=P;
}

void visu(a *P)
{
int compt=0;

do
{
printf("\n Le nom de la piece %d est :%s",compt,&P->id);
printf("\n Le prix de la piece %d est :%d",compt,&P->prix);
printf("\n Le code interne Correspondante de la piece %d est : %s",compt,&P->codint);
printf("\n La quantite en stock Correspondante est : %d",&P->stock);
compt++;
P=P->PP;
}
while(P->PP=NULL);
}

/*/////////////////////////////////////////////////////////////

CODE SOURCE

/////////////////////////////////////////////////////////////*/

int main()

{

a * TL=NULL; //Tête de liste
a * P=NULL; //structure de type pii
char rep; //variable recevant la reponse de lutilisateur

/////////////////////////////////

printf("Bonjour ! \n Nous allons creer la fiche d'une piece.");

do
{
CREA(&P);
CREALIFO(&P,&TL);

do
{
printf("Voulez vous rentrez une autre piece (o/n)?");
fflush(stdin);
scanf("%c",&rep);
}
while((rep!="o")||(rep!="n"));
}
while(rep="o");

printf("Nous allons visualisé la liste creer :\n");

visu(&TL);

printf("Merci d'avoir utiliser nos services =)");

system("PAUSE");
return 0;
}

Configuration: Windows XP
Firefox 2.0.0.14

mamiemando · Answer

Tu ne comprends pas pourquoi ton code ne marche pas, mais il ne compile même pas ?! En outre, le type pii n'est même pas défini.

Bon sinon il y a des choses qui ne vont pas :
- les noms des variables et de types sont incompréhensibles, pourquoi ne pas choisir quelque chose de plus explicite pour rendre ton code plus lisible ?
- les conventions de nommage du C ne sont pas respectée (constantes des #define en capitales ; types, variables, et fonctions en minuscules). Des conventions genre "un type a un nom se terminant par _t" est aussi appréciable pour la lisbilité.

Exemple
struct _piece_t{
  char id[45]; //Désignation de la pièce (45 lettres au plus),
  int prix; //prix
  int codint[5]; //Son Code interne (5 lettres au plus),
  int stock; //quantité en stock
  struct _piece_t * PP; //pointeur sur une la piece d'avant 
};

typedef struct _piece_t piece_t;
Essaye de reprendre ton programme proprement et surtout de l'écrire au fur et à mesure. Là il y a trop de choses à corriger et le programme est trop peu lisible pour que je le corrige.

Étant donné que tu as donné une taille statique à tes tableaux (id, code...) il est impératif de contrôler que la saisie tient dans ces tableaux, sinon tu vas faire une belle erreur de segmentation. Concrètement il suffit de stocker la valeur dans un buffer (genre un char buffer[255]) et de vérifier que la chaîne respecte bien les contraintes imposées par ta structure.

Si tu peux programmer en C++ je te conseille plutôt d'utiliser des std::string et des std::vector pour stocker ton id et ton code, et de contrôler au moment de les remplir que les contraintes de nombre de caractères sont respectées. C'est impérativement en C ou pas ?

Bonne chance

snowman · Answer

Ok merci pour l'aide je vais voir ce que je peux faire en le rendant plus lisible. Et oui je dois le coder en C, je n'ai jamais fait de C++.

snowman · Answer

En fait voici mon sujet pour que tout soit un peu plus clair sur l'objectif du code : )

Les données caractérisant les pièces détachées à gérer sont les suivantes :

• Désignation de la pièce (45 lettres au plus),
• Son Prix (nombre réel),
• Son Code interne (5 lettres au plus),
• La quantité en stock (entier).


Vous devez écrire un code qui contient :


• La définition d’une structure permettant de gérer des pièces dans une liste de
type « pile ». Elle doit donc posséder un pointeur sur « élément qui
précède ». Au total elle est constituée de 5 « champs ».

• Une fonction permettant la création d’une pièce. Cette fonction doit faire de
l’allocation dynamique de mémoire (fonction malloc), demander à
l’utilisateur de saisir les caractéristiques de la pièce, retourner l’adresse de la
pièce créée (Nota à ce moment, la pièce n’est pas dans une liste) ;

• Une fonction permettant d’insérer, dans une pile de pièces, une pièce. Cette
fonction doit avoir comme paramètres d’appel : l’adresse de la pièce à
insérer, la « tête de liste » (adresse de la dernière pièce introduite dans la
pile) ;

• Une fonction qui permet de visualiser toutes les pièces incluses dans une
pile, le paramètre d’appel est la « tête de liste » ;

• Le programme principal qui :
o Demande à l’utilisateur de créer une pièce (usage de la première
fonction),
o Insère cette pièce dans une liste chaînée (pile) de pièces (usage de la
deuxième fonction),
o Demande à l’utilisateur s’il veut ressaisir une pièce et revient au début
si la réponse est positive,
o Visualise toute la liste (usage de la troisième fonction), si l’utilisateur
ne veut plus saisir de pièce.

mamiemando · Answer

C'est une pile ou une liste chaînée que tu dois faire ?
As-tu vu les modules en cours (.h et .c) ?
Est ce que tu as bien compris ton cours sur les mallocs ?

Voici le découpage que je te propose (un void * désigne un pointeur générique) :

Un module liste.h / liste.c
#ifndef LIST
#define LIST

typedef struct _cell_t{
  void *data; // pointe sur la donnée contenue dans le maillon
  struct _cell_t *next; // pointe sur le maillon suivant (on pourrait rajouter un chainage vers le prédecesseur)
} cell_t;

typedef struct _list_t{
  cell_t *begin; // pointe sur la première cellule de la liste
  cell_t *end; // pointe sur la dernière cellule de la liste
} list_t;

// Créer une liste
list_t new_list();

// Ajouter en début de liste
void pop_back(list_t * l,const void *data);

// Ajouter en fin de liste
void push_back(list_t * l,const void *data);
Une fois que tu auras codé ce module on aura une structure de liste générique. Passons aux pièces :

piece.h / piece.c

typedef struct _piece_t{
  char *designation; //Désignation de la pièce (45 lettres au plus),
  double prix; //Son Prix (nombre réel),
  char *code; //Son Code interne (5 lettres au plus),
  unsigned quantite; //La quantité en stock (entier). 
} piece_t;

// Créer une pièce
piece_t new_piece(const char *designation,double prix,const char *code,unsigned quantite);

// Saisir une pièce
piece_t read_piece();

main.c
#include "list.h"
#include "piece.h"

int main(){
  //...
  return 0;
}
Pour compiler avec gcc :
gcc -c -W -Wall list.c
gcc -c -W -Wall piece.c
gcc -W -Wall -o plop.exe main.c list.o piece.o
Bonne chance

Exercice de prog

4 réponses

Discussions similaires

Newsletters