INSA/c
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Ajout du code de base

Browse source
This commit is contained in:
yoboujon 2022-11-24 13:45:31 +01:00
parent c6a1bd1462
commit 852d60c5a4
4 changed files with 265 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
coureur.c Normal file
View file

@ -0,0 +1,37 @@
#include "coureur.h" //inclure le fichier "coureur.h" qui contien les libs, structure et prototypes
// Creation d'un coureur en memoire avec recupération de son adrresse avec le parametrage de c'est different champs
coureur * creerCoureur(char nom[],char prenom[],int dossard, char equipe[],int temps)
{
coureur * leCoureur = malloc(sizeof(coureur)); //initilisation taille memoire taille de structure
leCoureur->nom = malloc(sizeof(char)*strlen(nom)); //initilisation taille memoire 4oct*tailleChaine
strcpy(leCoureur->nom,nom); //copy de nom(para) dans le champs nom de la structure leCoureur
leCoureur->prenom = malloc(sizeof(char)*strlen(prenom));//initilisation taille memoire 4oct*tailleChaine
strcpy(leCoureur->prenom,prenom); //copy de prenom(para) dans le champs prenom de la structure leCoureur
leCoureur->equipe = malloc(sizeof(char)*strlen(equipe));//initilisation taille memoire 4oct*tailleChaine
strcpy(leCoureur->equipe,equipe); //copy de equipe(para) dans le champs equipe de la structure leCoureur
leCoureur->temps=temps; //ecriture temps(para) dans le champs temps de la structure leCoureur
leCoureur->dossard=dossard; //ecriture dossard un int dans le champs dossard de la structure leCoureur
return leCoureur; //retour addresse de la structure crée "leCoureur"
}
//Modifier le temps d'un coureur a partir de son adresse et d'une valeur de cumule
void ajouterTemps(int leTemps,coureur * leCoureur)
{
leCoureur->temps+=leTemps; //Cumul du champ temps appartenant a la structure leCoureur avec leTemp(para) qui est un int
}
//Afficher le temps d'un coureur stocker en seconde sous forme d'heures, de minutes et de secondes ( a partir de l'adresse de sa structure de définition)
void afficherCoureur(coureur * leCoureur)
{
int heure,minute,seconde; //initilisation de 3 variable tampon
heure = (int)(leCoureur->temps)/3600; //calcul d'heures qui renvoie uniquement la partie entier
minute = (int)((leCoureur->temps-heure*3600)/60); //calcul de minutes qui renvoie uniquement la partie entier avec la prise en compte des heures soustraite en minutes
seconde = leCoureur->temps-(heure*3600+minute*60); //calcul de seconde qui renvoie uniquement la partie entier avec la prise en compte des heures soustraite en secondes et des minutes en secondes
printf("Nom : %s\tPrenom : %s\tDossard : %d\tEquipe : %s\tTemps : %d:%d:%d\n",leCoureur->nom,leCoureur->prenom,leCoureur->dossard,leCoureur->equipe,heure,minute,seconde);
}

17
coureur.h Normal file
View file

@ -0,0 +1,17 @@
#include <stdio.h> //lib de base
#include <stdlib.h> //lib de base
#include <string.h> //lib de base
#include <stdbool.h> //lib de base
typedef struct{ //definition de la structure coureur
char * nom;
char * prenom;
int dossard;
char * equipe;
int temps;
} coureur;
//Prototype
coureur * creerCoureur(char nom[],char prenom[],int dossard, char equipe[],int temps);// Creation d'un coureur en memoire avec recupération de son adrresse avec le parametrage de c'est different champs
void ajouterTemps(int leTemps,coureur * leCoureur); //Modifier le temps d'un coureur a partir de son adresse et d'une valeur de cumule
void afficherCoureur(coureur * leCoureur); //Afficher le temps d'un coureur stocker en seconde sous forme d'heures, de minutes et de secondes ( a partir de l'adresse de sa structure de définition)

184
liste.c Normal file
View file

@ -0,0 +1,184 @@
#include "liste.h"
int main(void)
{
coureur * c1 = creerCoureur("Paris","Simon",15,"TRAUFORE",50000); //creation coureur
coureur * c2 = creerCoureur("Bougeont","Yoann",65,"MEILLEUR",99994); //creation coureur
coureur * c3 = creerCoureur("Barakai","Obama",120,"AMERICA",372); //creation coureur
coureur * c4 = creerCoureur("Boujon","Yohan",56,"MAISYEUR",49999); //creation coureur
coureur * c5 = creerCoureur("Runner","Tedi",1,"JUDOOOKA",120); //creation coureur
coureur * c6 = creerCoureur("Fatigue","Jean",69,"DODODODO",11554751); //creation coureur
printf(" -- COUREUR -- \n");
afficherCoureur(c1); //Afficher les champs de la structure coureur c1
ajouterTemps(50,c1); //Ajoutee 50 seconde dans le champ temp de c1
afficherCoureur(c1); //Afficher les champs de la structure coureur c1
liste l1 = initListe(); //declaration de la liste l1 et initialisation
ajoutListe(&l1,c1); //ajout d'un element contenat c1 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global)
ajoutListe(&l1,c2); //ajout d'un element contenat c2 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global)
ajoutListe(&l1,c3); //ajout d'un element contenat c3 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global)
ajoutListe(&l1,c4); //ajout d'un element contenat c4 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global)
ajoutListe(&l1,c5); //ajout d'un element contenat c5 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global)
ajoutListe(&l1,c6); //ajout d'un element contenat c6 dans liste l1(a partir de son adresse modfication a la maniere d'une variable global)
printf(" -- AJOUT LISTE, taille =%d -- \n",tailleListe(l1));
printlist(l1);
effacerCoureur(&l1,c2);
printf(" -- SUPR LISTE, taille =%d -- \n",tailleListe(l1));
printlist(l1);
printf(" -- INTERVERTI COUREUR 1 ET 2 DE LA LISTE -- \n");
invertCoureur(&l1,1);
printlist(l1);
printf(" -- INTERVERTI COUREUR 0 ET 1 DE LA LISTE -- \n");
invertCoureur(&l1,0);
printlist(l1);
printf(" -- COUREUR 2 DE LA LISTE -- \n");
afficherCoureur(getCoureur(l1,2));
printf(" -- TRI LISTE -- \n");
triListe(&l1,tailleListe(l1));
printlist(l1);
return 0;
}
struct element * initElement(void)
{
struct element * returnElement = (struct element *)malloc(sizeof(struct element));
returnElement->coureurActuel = creerCoureur("","",0,"",0);
returnElement->suiv = NULL;
return returnElement;
}
liste initListe(void)
{
liste l;
l.debut=initElement();
l.fin=initElement();
l.courant=initElement();
return l;
}
void ajoutListe(liste * listeActuel,coureur * leCoureur) //avec "leCoureur" le coureur a rajouter
{
struct element * elementActuel = (struct element *)malloc(sizeof(struct element)); //declaration et allocation en memoire(a l'adresse *elementActuel) d'une taille de structure element de type element (Creation element vierge de taille element)
elementActuel->coureurActuel=leCoureur; //dans la variable elementActuel le champ coureurActuel devient leCourreur (l'element vierge est remplie avec le coureur a rajoute)
elementActuel->suiv=listeActuel->courant; //dans la variable elementActuel le champ suiv devient le poiteur courant (l'element vierge poite sur le debut le poiteur courant (le premier element)chainage)
listeActuel->debut=elementActuel; //le poiteur de premiere element contenue dans liste pointe sur le nouvelle element
listeActuel->courant=elementActuel; //le poiteur courant contenue dans la liste pointe sur le nouvelle element
}
void printlist(liste l)
{
struct element * eCourant = l.courant;
struct element * eFin = l.fin;
while(eCourant->suiv != eFin->suiv)
{
afficherCoureur(eCourant->coureurActuel);
eCourant=eCourant->suiv;
}
printf("NULL \n");
}
void allerDebut(liste * l)
{
l->courant = l->debut;
}
void allerFin(liste * l)
{
l->courant = l->fin;
}
void avancer(liste * l)
{
l->courant = l->courant->suiv;
}
coureur * coureurCourant(liste * l)//------------------------------------------------------------------------Artefacte
{
return l->courant->coureurActuel;
}
void effacerCoureur(liste * listeActuel,coureur * coureurSuppr)
{
struct element * eParcours = listeActuel->courant;
struct element * ePrevious;
if(eParcours->coureurActuel == coureurSuppr)
{
listeActuel->courant=eParcours->suiv;
listeActuel->debut=eParcours->suiv;
}
else{
ePrevious=eParcours;
eParcours=eParcours->suiv;
while(eParcours->coureurActuel != coureurSuppr){
ePrevious=ePrevious->suiv;
eParcours=eParcours->suiv;
}
ePrevious->suiv=eParcours->suiv;
free(eParcours);
}
}
int tailleListe(liste l)
{
int returnValue=0;
struct element * elementActuel = l.courant;
while(elementActuel->suiv != l.fin->suiv)
{
returnValue++;
elementActuel=elementActuel->suiv;
};
return returnValue;
}
coureur * getCoureur(liste l,int nb)
{
struct element * elementCourant = l.courant;
for(int i=0;i<nb;i++)
{
elementCourant=elementCourant->suiv;
}
return elementCourant->coureurActuel;
}
void invertCoureur(liste * l,int nb)
{
struct element * elementCourant = l->courant;
struct element * elementPrecedent = (struct element *)(malloc(sizeof(struct element)));
for(int i=0;i<nb;i++)
{
elementPrecedent = elementCourant;
elementCourant=elementCourant->suiv;
}
struct element * elementSuivant = elementCourant->suiv;
elementCourant->suiv=elementSuivant->suiv;
elementSuivant->suiv=elementCourant;
if(nb==0)
{
l->courant=elementSuivant;
l->debut=l->courant;
}
else{
elementPrecedent->suiv = elementSuivant;
l->courant=l->debut;
}
}
void triListe(liste * l,int taille)
{
bool tabOrdered = true;
for(int i=taille-1;i>1;i--)
{
for(int j=0;j<=i-1;j++)
{
if(getCoureur(*l,j+1)->temps < getCoureur(*l,j)->temps)
{
invertCoureur(l,j);
tabOrdered = false;
}
printlist(*l);
}
if(tabOrdered)
{
return;
}
}
}

27
liste.h Normal file
View file

@ -0,0 +1,27 @@
#include "coureur.h" //inclure le fichier "coureur.h" qui contien les libs et la structure coureur
struct element{ //definition de la structure qui element qui sera encaspule/chaine
coureur * coureurActuel; //"contient" l'adresse d'une structure coureur
struct element * suiv; //"contient" l'adresse d'une autre strucutre element(chainage)
};
typedef struct{ //definition de la structure liste qui "contient" l'encaspsulation
struct element * debut; //"contient" un element en debut *voir init dans liste.c
struct element * courant; //"contient"element actuel *voir init dans liste.c
struct element * fin; //"contient"element en fin de la liste (NULL) *voir init dans liste.c
} liste;
//Prototype de fonction
struct element * initElement(void); //initialise un element en memoir qui encapsule une strucure de coureurau champs vide
liste initListe(void); //initialise chaque element de la liste a partir de initElement
void ajoutListe(liste * listeActuel,coureur * leCoureur); //ajoute un element contenant un courreur dans le chainage d'une liste
void printlist(liste l); //afficher le coureur dans chaque element d'une liste
void allerDebut(liste * l); //mettre le poiteur courant sur l'element premier d'une liste
void allerFin(liste * l); //mettre le poiteur courant sur l'element de fin d'une liste
void avancer(liste * l); //mettre le poiteur courant sur l'element suivant de la liste dans la qu'elle qu'il pointe
coureur * coureurCourant(liste * l); //rien a foutre ici
void effacerCoureur(liste * listeActuel,coureur * coureurSuppr);//enleve un element d'une liste a partir de l'adresse d'un courreur, sans briser le chainage
int tailleListe(liste l); //retourne le nombre d'elements chaine d'une liste
coureur * getCoureur(liste l,int nb); //
void invertCoureur(liste * l,int nb); //
void triListe(liste * l,int taille); //trie bulle des element d'une liste a partir du temps contenue dans la structure encapsule dans l'element