Mini projet Programmation I __1AGE2
SOMMAIRE
1 Introduction sur le langage C :
1.1 les avantages..................................................................................03
1.2 Les inconvénients............................................................................04
1.3bibliothèque......................................................................................05
2 Comparaison entre version statique et version dynamique
2.1 Version statique...............................................................................07
2.2 Version dynamique .........................................................................07
3 Notre mini projet
3.1- Description du projet......................................................................08
3.2-partie statique..................................................................................09
3.2.1 Fonction dessin............................................................................09
3.2.2 Fonction tout.................................................................................11
3.3-Partie dynamique.............................................................................14
3.3.1 Fonction init_list............................................................................15
3.3.2 Fonction ajouter............................................................................15
3.3.3 Fonction comparaison...................................................................15
3.3.4 Fonction test..................................................................................16
3.3.5 Fonction affiche.............................................................................17
3.4 Programme principale........................................................................17
3.4.1 Fonction logo ................................................................................18
3.4.2 Fonction menu................................................................................18
3.4.3 Fichiers...........................................................................................19
4 Conclusion
5 Bibliographie
ENIT 2006/2007 __MOTUS 1
Mini projet Programmation I __1AGE2
Mini Projet
Programmation I
Réalisé par :
MIMOUN WIEM
ZIEDI MAROUEN
1AGE2
ENIT 2006/2007 __MOTUS 2
Mini projet Programmation I __1AGE2
Introduction sur le C
C C'est une version améliorée du langage de programmation B du Bell Laboratory, créé
en1972
Le langage C est un langage évolué et structuré, assez proche du langage machine destiné à
des applications de contrôle de processus (gestion d'entrées/sorties, applications temps
réel ...)
Les compilateurs C possèdent les taux d'expansion les plus faibles de tous les langages
évolués (rapport entre la quantité de codes machine générée par le compilateur et la quantité
de codes
machine générée par l'assembleur et ce pour
une même application);
Caractéristiques du programme C
Comme tout langage de programmation, le C présente des avantages, mais aussi quelques
inconvénients. On va les résumer très brièvement ci-dessous:
1)Les avantages:
Universalité:
Ce langage peut être adapté à de nombreuses machines, dans de nombreux buts. Pour
preuve, il a bien été adapté pour les TI_89, TI_92,et V8200 !
Modernité:
Le C offre de nombreuses possibilités, comme des structures de répétition , de conditions, de
déclarations, que l’on retrouve d’ailleurs dans la majorité des « grands » langages de notre
temps.
Rapidité:
essayez donc de faire des programmes en TI_BASIC qui aillent à la même
vitesse que leurs équivalents en C (cela est du au fait que le C est un langage compilé ,à la
différence du TI_BASIC, qui est un langage interprété).
Extensibilité:
Le C n’utilise pas seulement des fonctions standard, mais aussi des fonctions incluses dans les
librairies, qui permettent au langage d’être simple et concis, tout en autorisant les
compilateurs à proposer un grand nombre de fonction, via les librairies qu’ils fournissent au
ENIT 2006/2007 __MOTUS 3
Mini projet Programmation I __1AGE2
programmeur. Ainsi, ce langage est basé sur un petit nombre d’instructions, complétés par
des fonctions (la version 2.3 des librairies de TIGCC en regroupe environ 800), qui sont donc
« peu nombreuses » à retenir, mais qui permettent de faire un grand nombre d’opérations, et
ce en manipulant uniquement des opérations simples, ou que l’on arrive à considérer comme
telles une fois qu’on a acquis un minimum d’expérience.
2)Les inconvénients:
Aucun langage de programmation ne peut être parfait. Le C n’échappe naturellement pas
à cette règle. Le C, bien que généralement assez facile à programmer, est un langage qui peut
comporter des « piéges ».
En effet,il n’est pas rare de commencer un programme assez complexe , de le laisser
momentanément(pour cause de vacances , par exemples),et de vouloir le finir deux semaines
plus tard. Le risque est que , au bout de cette période, le programme soit devenu
incompréhensible, pour cause d’enchaînements illogiques de fonctions. Il vaut donc souvent
mieux placer un grand nombres de commentaires dans ses programmes, quitte à perdre un
peu de temps, plutôt que de vouloir aller vite , et, au final, en perdre encore plus.
3)La bibliothèque standard du C :
De nombreux utilitaires qui sont utilisés des les
programmes ne font pas partie de « bibliothèques standard »
qui sont écrites en C pour être utilisés par d’autres programmes C.
Ces utilitaires comprennent:
1-signaux(exceptions) et autres fonctions de contrôle
non locales.
2-opérations sur les caractères et les chaînes de caractère.
3-calcul et impression de l’heure du jour.
4-opérations sur des blocs arbitraires de mémoire.
5-fonctions d’entée et de sortie.
6-comunication avec le système d’exploitation
Le langage C possède assez peu d'instructions, il fait par contre appel à des bibliothèques,
fournies en plus moins grand nombre avec le compilateur.
Et parmi ses bibliothèques, on cite:
<stdio.h>:
Fournit les capacités centrales d’entrée/sortie du langage C.
Ce fichier inclut la vénérable fonction printf().
<ctype.h>:
ENIT 2006/2007 __MOTUS 4
Mini projet Programmation I __1AGE2
Fonctions utilisées pour classifier rapidement les caractères,ou
Pour convertir entre majuscules et minuscules de manière indépendante
du système de codage des caractères.
<stdlib.h>:
Pour exécuter diverses fonctions dont la conversion, la génération de nombres pseudo
aléatoires, l’allocation de mémoire, le contrôle de processus, la gestion de l’environnement et
de signaux, la recherche et le tri.
<time.h>:
Pour convertir entre différents formats de date et d’heure.
<limits.h>:
Contient des constantes qui spécifient les propriétés des types entiers qui dépendent
l’implémentation , comme les intervalles des nombres pouvant être
représentés(xxx_MIN,xxx_MAX).
<locale.h>:
Pour s’adapter aux différentes conventions culturelles.
<wchar.h>:
Pour manipuler les caractères larges (wider char),nécessaire pour supporter un grand nombre
de langues et singulièrement Unicode (introduit par Amd.1).
<string.h>:
Pour manipuler les chaînes de caractères( celle qui sont gérée….).
<assert.h>:
Contient la macro assert(),utilisée pour aider à détecter des
incohérences de données et d’autres types de bogues dans les
versions de déboguage d’un programme.
<math.h>:
Pour calculer des fonctions mathématiques courantes.C99 a ajouté
de nombreuses fonctions mathématiques, en particulier pour
converger avec la norme CE559 dite aussi IEEE 754.
Chacun de ces utilitaires fait partie d’une bibliothèque particulière .La façon correcte
d’utiliser un utilitaire est d’insérer une commande de pré processeur « #include »au début du
programme utilisateur pour inclure les déclarations de bibliothèques utiles;l’utilitaire peut
alors être appelé à l’intérieur du programme utilisateur .Par exemple, afin d’utiliser la
fonction
ENIT 2006/2007 __MOTUS 5
Mini projet Programmation I __1AGE2
trigonométrique COS dans un programme ,le programmeur C doit insérer la commande
#include<math.h> au début de programme permettant de déclarer COS afin de l’utiliser
ultérieurement.
On ne saurait développer un programme en C sans se munir de la documentation concernant
ces bibliothèques .On ne saurait développer un programme en C sans se munir de la
documentation concernant ces bibliothèques.
Et voici, un diagramme qui schématise la compilation du programme en langage C et son
exécution avec les bibliothèques :
oui non
condition
vraie
bloc d'
instructions
ENIT 2006/2007 __MOTUS 6
Mini projet Programmation I __1AGE2
Comparaison entre la version statique et la version
dynamique
Version statique
Allocation fixe de la mémoire. Elle utilise les tableaux de dimensions finis caractérisé par
rapidité et la facilité de :
1-L’accès
2-L’ajout et la destruction à la fin.
3-L’accès au n iéme élément.
4- La recherche et le parcours.
Version dynamique
Allocation de la mémoire selon les besoins. Elle utilise des listes chaînées pour stocker les
données ou:
1-L’insertion est plus rapide.
2-la distraction au milieu est plus rapide.
3-La libération d’espace mémoire alloué à
une Variable qui n’est plus utilisée, même
avant la fin du programme, est possible
à tout moment .
4-le parcours est séquentiel.
ENIT 2006/2007 __MOTUS 7
Mini projet Programmation I __1AGE2
NOTRE MINI PROJET
Il s’intitule sur l’implantation du jeu MOTUS simple .Ce jeu repose sur la recherche de mots
de cinq lettres. A chaque étape le joueur propose un mot. Ce dernier a le droit de six essais
Dans la fenêtre d’exécution le jeu affiche:
1- Les lettres qui sont a leurs positions en rouge.
2- Les lettres faisant partie du mot recherché,mais mal placées en jaune.
3- Le caractère « + » pour les lettres inexistant .
1)Description détaillée de notre projet
Ce mini projet , MOTUS, est composé de deux parties différentes:une partie statique et une
partie dynamique.
Dans la première on va utiliser un tableau dans lequel on va stocker le mot à deviner afin
de le comparer avec le mot proposé par le [Link] que pour la deuxième on va utiliser
une liste chaînée.
Concernant les variables utilisées, on distingue deux types de déclaration: Une locale et
une autre globale. Il s’agit dans le premier type d’ une déclaration à l’intérieur de chacune
des fonctions pour que la variable ne soit que pour cette dernière par contre la déclaration
globale se fait dans le programme principal pour que toutes les fonctions puissent l’utiliser.
2)LA PARTIE STATIQUE
Cette version nécessite l’utilisation d’un tableau qui est une collection de variables sous un
même nom. Toutes les variables doivent être de même type possédant des propriétés
identiques.
Utilisation: Un élément du tableau est repéré par son indice.
En langage C les tableaux commencent à l'indice 0. L'indice maximum est
donc dim-1.
Appel: nom[indice]
ENIT 2006/2007 __MOTUS 8
Mini projet Programmation I __1AGE2
Tous les éléments d'un tableau (correspondant au dimensionnement maximum) ne sont pas
forcément définis.
D'une façon générale, les tableaux consomment beaucoup de place en mémoire ,on a donc
intérêt à les dimensionner au plus juste.
Les différentes fonctions implémentées
1-Fonction DESSIN:
Son prototype
void dessin (int x,int y,int k,int l)
{
int i;
if(l==0)
for(i=0;i<=k;i++) {
textcolor(4);
gotoxy(x+i,y);cprintf("*");} else for(i=0;i<=k;i++) {
textcolor(4);
gotoxy(x,y+i);cprintf("*");}
getch();}
Cette fonction permet d’afficher en mode graphique selon l’heure récupéré par le système,
un message « BIEN » ou « BYE » selon le besoin de notre appel .Elle sert à bien présenter
notre programme dans la fenêtre d’exécution .
A fin d’exécuter cette fonction on recourt à des fonctions prédéfinies dans des
bibliothèques standards appropriés.
ENIT 2006/2007 __MOTUS 9
Mini projet Programmation I __1AGE2
gotoxy
elle se trouve dans <conio.h>a pour objectif de placer le curseur dans
la fenêtre texte
Déclaration:
void gotoxy(int x,int y);
gotoxy positionne le curseur dans la fenêtre à la position(x,y).
Elle est ignorée si les coordonnées sont invalides.
Time
récupère l'heure système .Définie sur <time.h >
Déclaration:
time_t time(time_t *timer);
time_t est le nombre de seconde qui placé dans l'adresse *timer.
time renvoie le temps écoulé en seconde.
Textbackground,Textcolor
textbackground:contrôle la couleur du fond de l'écran.
textcolor:contrôle la couleur du texte.
elles sont définies sur <conio.h>
Déclaration:
void textbackground(int new color).
void textcolor(int new color).
la valeur indiquant la couleur des caractère est [0..15]celle du fond est entre [0..7]
Pour avoir un texte clignotant on ajoute -128-à la valeur de la couleur du caractère.
2-La fonction TOUT
ENIT 2006/2007 __MOTUS 10
Mini projet Programmation I __1AGE2
Cette fonction permet de tester le mot saisie par le joueur et le comparer avec le mot à
trouver. Pour chaque frappe cette fonction vérifie si elle est une lettre à l’aide du boucle «
while ».
Le parcours du mot à deviner se fait avec le boucle « for » . Choisir d’ une manière aléatoire
à l’ aide de la fonction « random » un des mots à deviner proposés par la fonction « switch ».
Randomise
randomise initialise le générateur interne de nombres aléatoires
avec une valeur aléatoire.
Déclaration:
void randomise(void);
elle ne retourne rien.
Random
random renvoie un nombre aléatoire,et définie sur <stdlib.h.>
Déclaration:
random(num);
elle renvoie le nombre aléatoire compris entre 0 et num-1.
Les boucles utilisées dans le programme
switch
switch est similaire à l’instruction 'case of' de pascal .Elle permet une
décision entre des cas multiples sans utiliser l’instruction if.
Déclaration:
switch(<expression>)
case<expression_const>:<instruction>;
break default:<instruction>;
While
Il s'agit de l'instruction:
tant que (expression vraie)
faire{BLOC D'INSTRUCTIONS}
Syntaxe en C:
while (expression)
ENIT 2006/2007 __MOTUS 11
Mini projet Programmation I __1AGE2
{
/* bloc d'instructions */
}
Le test se fait d'abord, le bloc d'instructions n'est pas forcément exécuté.
Remarques:
* les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.
*On peut rencontrer la construction suivante: while (expression); terminée par un ; et sans la
présence du bloc d'instructions. Cette construction signifie: "tant que l'expression est vraie
attendre".
Son organigramme :
oui non
condition
vraie
bloc d'
FOR
instructions
Il s'agit de l'instruction:
pour (initialisation; condition de continuité vraie;modification
{BLOC D'INSTRUCTIONS}
Syntaxe en C:
for(initialisation ; condition de continuité ; modification)
{
/* bloc d'instructions */
}
Remarques:
Les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.
Les 3 instructions du for ne portent pas forcément sur la même variable.
Une instruction peut être omise, mais pas les ;
Son organigramme :
ENIT 2006/2007 __MOTUS 12
Mini projet Programmation I __1AGE2
oui non
condition
vraie
bloc d'
instructions
IF
Il s'agit de l'instruction:
si (expression conditionnelle vraie)
alors {BLOC 1 D'INSTRUCTIONS}
sinon {BLOC 2 D'INSTRUCTIONS}
Syntaxe en C:
if (expression)
{
/* bloc 1 d'instructions */
}
else
{
/* bloc 2 d'instructions */
ENIT 2006/2007 __MOTUS 13
Mini projet Programmation I __1AGE2
Son organigramme :
oui condition non
vraie
bloc 1 d' bloc 2 d'
instructions instructions
suite du programme
3)PARTIE DYNAMIQUE
But
A cause de la difficulté de l’estimation de la taille nécessaire d’un
tableau;en général,seulement 20% à 30% du tableau sont utilisés ie
gaspillage de ressources
En plus, l’ajout de nouveaux éléments dans un tableau est coûteux de
calcul(algorithme).
C’est pour cette raison qu’on a procédé à la version dynamique.
Cette version présente un programme utilisant une gestion dynamique de
la mémoire:
ENIT 2006/2007 __MOTUS 14
Mini projet Programmation I __1AGE2
*Demande d’espace mémoire selon les besoins.
*L’utilisation de la mémoire heap.
L’allocation dynamique de la mémoire se fait en utilisant la liste chaînée
qui est une structure comportant deux champs contenant des données ou
information (data) et un pointeur vers une structure de même type.
* Le champ information est spécifique à l’application.
* Le champ pointeur implante la récursivité.
Les différentes fonctions implémentées
1-Fonction init_list :
Son prototype :
void init_list (list *lc)
{
lc->t=(node*) malloc (sizeof(node));
lc->c=lc->t;
lc->t->p=NULL;
}
Cette fonction permet de mettre les deux pointeurs à null.
2-fonction ajouter :
Son prototype :
Void ajouter (char x , list *lc)
{
node *q;//pointeur de travail
q=(node*) malloc (size of (node));
q->data=x;
q->p=lc->c->p;
lc->c->p=q;
lc->c=lc->c->p;
}
Cette fonction qui permet de stocker le mot de 5 lettres dans une liste
Elle permet de créer un nœud vide, puis mettre le caractère dans le nœud
Ensuite elle permet le chaînage au successeur et au prédécesseur.
3-Fonction comparison :
Son prototype :
void comparaison(list *lc, list *l)
{
node *q, *k;
lc->c=lc->t->p
l->c=l->t->p;
ENIT 2006/2007 __MOTUS 15
Mini projet Programmation I __1AGE2
while(lc->c!=NULL)
{
if((lc->c->data)==(l->c->data))
{
textcolor(RED);
cprintf("%c",l->c->data);
}
else
{
q=lc->t->p ;
k=l->t->p ;
while((q->p!=NULL) && (q->p->data!=l->c->data))
{
q=q->p; //
k=k->p;
}
if((q->p!=NULL) && (q->p->data!=k->p->data))
{
fflush(stdin);
textcolor(YELLOW);
cprintf("%c",l->c->data);
}
else
printf("+");
}
lc->c=lc->c->p;
l->c=l->c->p;
}
}
Fonction permettant de comparer deux listes chaînées , une à sa bonne
place marquée en rouge , une lettre mal placée en jaune et une lettre
inexistante sera remplacée par « + »
4-Fonction test:
Son prototype:
int test(list *lc, list *l)
{
lc->c=lc->t->p;
l->c=l->t->p;
while(lc->c!=NULL && (lc->c->data==l->c->data))
{
lc->c=lc->c->p;
l->c=l->c->p;
}
if(lc->c==NULL)
return 1;
else
ENIT 2006/2007 __MOTUS 16
Mini projet Programmation I __1AGE2
return 0;
}
Fonction qui teste les deux listes et retourne 1 si le mot désiré est trouvé
5-Fonction affiche :
Son prototype :
void affiche(list *lc)
{
int k;
lc->c=lc->t->p;
for(k=0;lc->c!=NULL; k++)
{
printf("%c",lc->c->data);
lc->c=lc->c->p;
}
}
Cette fonction affiche la liste chaînée à deviner en cas de 6 essais échoués
Exécution :
4) PROGRAMME PRINCIPALE :
Le void Main programme permet la gestion des fonctions définies au
début du programme et il utilise d’autres fonctions qui sont les suivantes :
Les différentes fonctions implémentées
1-fonction logo :
Son prototype :
ENIT 2006/2007 __MOTUS 17
Mini projet Programmation I __1AGE2
void logo()
{
printf("\t\t*** *** **** ******** ** ** ****** \n");
printf("\t\t** *** ** ** ** ******** ** ** ** \n");
printf("\t\t** * ** ** ** ** ** ** ****** \n");
printf("\t\t** ** ** ** ** ** ** ****** \n");
printf("\t\t** ** ** ** ** ** ** ** \n");
printf("\t\t** ** **** ** *** ****** \n");
}
2-Fonction menu:
son prototype:
void menu()
{
gotoxy(50,9);textcolor(134);cprintf("***************");
gotoxy(50,11);cprintf("***************");gotoxy(50,10);cprintf("***
***");
gotoxy(56,10);cprintf("*");
gotoxy(53,10)
;textcolor(15);cprintf("JEU"),gotoxy(57,10);cprintf("MOTUS");
printf("\n\n\n\nChoisissez l'une des deux solutions suivantes:\n");
printf("\n\na) Solution statique\n\nb) Solution dynamique\n\nc)
Quitter\n\nSVP taper 'a', 'b'ou 'c' selon votre choix :");
}
la fonction menu permet de choisir l'option voulue voir l’exemple ci-
dessous :
ENIT 2006/2007 __MOTUS 18
Mini projet Programmation I __1AGE2
3-Les fichiers
Dans notre programme, et dans la partie dynamique, on a utilisé le
fichier ou on va sauvegarder nos mots à deviner. C’est pour cela le
programmeur doit stocker ses mots dans le fichier avant le début du jeu.
Ainsi, l’ouverture du fichier se fait en deux modes :
Ouverture du fichier en écriture pour stocker les mots à deviner :
f1=fopen(nom1,"w");
if(!f1)
{
printf("\n ouverture du fichier %s!\n",nom1);
/*exit(-1);*/
}
for(k=0;k<N;k++)
{
i=0;
while(i<5)
{
fprintf(f1,"%c",a[k][i]);
fflush(stdin);
i++;
}
}
fclose(f1);
Ouverture de fichier en lecture pour les comparer avec les mots
proposés du joueur :
f1=fopen(nom1,"r");
if(!f1)
{
printf("\nouverture du fichier %s!\n",nom1);
CONCLUSION
De ce qui précède on peut conclure que d’après ce mini projet la
programmation en utilisant deux versions : statique et dynamique, on a pu
déterminer les avantages et les inconvénients de chaque version, ce qui
ENIT 2006/2007 __MOTUS 19
Mini projet Programmation I __1AGE2
nous a permis d’approfondir nos connaissances acquises pendant les
cours de programmation et nous ouvrir de larges horizons pour leurs
applications dans la vie courante.
BIBLIOGRAPHIE:
Cours de programmation de [Link] FRHIDA , HAMROUNI KAMEL
Quelques sites utiles:
[Link]
ENIT 2006/2007 __MOTUS 20
