API

REPUBLIQUE TUNISIENNE
MINISTERE DE LENSEIGNEMENT SUPERIEUR ET DE

LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES
UNIVERSITE DE JENDOUBA
FACULTE DES SCIENCES JURIDIQUES, ECONOMIQUES ET DE GESTION DE JENDOUBA
FASCICULE DE Cours et TPs
Atelier de Programmation I
Adress aux tudiants de 1re anne Licence Fondamentale en
Informatique Applique la Gestion
Riadh BOUSLIMI
Assistant en Informatique
Anne Universitaire : 2009-2010
FICHE MATIRE
Objectifs gnraux
Il s'agit d'un cours d'initiation au langage C. Ce cours s'adresse aux dbutants en
programmation. Il a pour but de:
- Dcouvrir l'environnement de programmation C.
- Etre capable d'crire ses premiers programmes dans le langage de programmation C.
- Acqurir les notions principales pour apprendre rapidement d'autres langages de
programmation
- Savoir ragir devant un problme de programmation.
Pr-requis
Algorithmiques et structures de donnes
Public-cible
Ce cours est destin essentiellement aux tudiants de la premire anne Licence fondamentale
en Informatique applique la Gestion, semestre1
Volume horaire
Ce cours est prsent, de manire hebdomadaire, comme suit:
- 45mn du cours intgr en sance de TD
- 1h30mn de Travaux pratiques pour chaque groupe
Soit en total : 31.5h
Moyens pdagogiques
- Tableau
- Condens du cours
- Salle de TD - Laboratoire d'informatique
- Polycopies des Travaux pratiques
- L'environnement de programmation C : Turbo C++
Evaluation
- Coefficient : 1.5
- Note du contrle continu : 30%
- Note d'examen : 70%
2/76
Table des matires

Chapitre 1 : ELEMENTS DE LANGAGE C.....................................................................................................................6
1.
INTRODUCTION ........................................................................................................................................6
2.
ETAPES PERMETTANT L'EDITION, LA MISE AU POINT, L'EXECUTION D'UN
PROGRAMME ........................................................................................................................................................6
3.
LES DIFFERENTS TYPES DE VARIABLES..........................................................................................7
4.
LES INITIALISATIONS.............................................................................................................................9
5.
SORTIES DE NOMBRES OU DE TEXTE A L'ECRAN.......................................................................10
6.
LES OPERATEURS ..................................................................................................................................12
7.
LES CONVERSIONS DE TYPES ............................................................................................................13
Chapitre 2 : SAISIE DE NOMBRES ET DE CARACTERES AU CLAVIER.............................................................15
1.
LA FONCTION GETCH...........................................................................................................................15
2.
LA FONCTION SCANF............................................................................................................................15
3.
LA FONCTION GETCHAR.....................................................................................................................16
Chapitre 3 : LES STRUCTURES CONDITIONNELLES ET LES BOUCLES ..........................................................17
1.
L'INSTRUCTION SI ... ALORS ... SINON ... .........................................................................................17
2.
LES OPERATEURS LOGIQUES ............................................................................................................18
3.
L'INSTRUCTION AU CAS OU ... FAIRE ... ..........................................................................................19
4.
LA BOUCLE TANT QUE ... FAIRE .......................................................................................................20
5.
L'INSTRUCTION POUR .........................................................................................................................21
6.
L'INSTRUCTION REPETER ... TANT QUE ........................................................................................22
Chapitre 4 : LES TABLEAUX ET LES CHAINES DE CARACTERES .....................................................................24
1.
LES TABLEAUX DE NOMBRES (INT ou FLOAT) .............................................................................24
2.
INITIALISATION DES TABLEAUX......................................................................................................25
3.
LES CHAINES DE CARACTERES ........................................................................................................25
4.
FONCTIONS SUR LES CHAINES DE CARACTERES .......................................................................26
Chapitre 5 : LES FONCTIONS........................................................................................................................................27
1.
INTRODUCTION ......................................................................................................................................27
2.
DECLARATION ........................................................................................................................................27
3.
FONCTIONS SANS PASSAGE D'ARGUMENTS ET NE RENVOYANT RIEN AU
PROGRAMME. .....................................................................................................................................................28
4.
FONCTION RENVOYANT UNE VALEUR AU PROGRAMME ET SANS PASSAGE
D'ARGUMENTS....................................................................................................................................................31
5.
FONCTIONS AVEC PASSAGE D'ARGUMENTS ................................................................................31
6.
RESUME SUR VARIABLES ET FONCTIONS.....................................................................................32
7.
LE PASSAGE DE PARAMETRES ENTRE FONCTIONS OU ENTRE FONCTIONS ET
PROGRAMME PRINCIPAL ...............................................................................................................................32
TP n1..................................................................................................................................................................................34
Exercice 1 ................................................................................................................................................................34
Exercice 2 ................................................................................................................................................................34
Exercice 3 ................................................................................................................................................................34
Exercice 4 ................................................................................................................................................................34
Exercice 5 ................................................................................................................................................................34
Correction du TP n1.........................................................................................................................................................35
Exercice 1 ................................................................................................................................................................35
Exercice 2 ................................................................................................................................................................35
Exercice 3 ................................................................................................................................................................35
Exercice 4 ................................................................................................................................................................36
Exercice 5 ................................................................................................................................................................36
TP n2..................................................................................................................................................................................37
Exercice 1 ................................................................................................................................................................37
Exercice 2 ................................................................................................................................................................38
Exercice 3 ................................................................................................................................................................38
Exercice 4 ................................................................................................................................................................38
Exercice 5 ................................................................................................................................................................38
Exercice 6 ................................................................................................................................................................38
Exercice 7 ................................................................................................................................................................38
Exercice 8 ................................................................................................................................................................39
Exercice 9 ................................................................................................................................................................39
3/76
Exercice 1 ................................................................................................................................................................40
Exercice 2 ................................................................................................................................................................40
Exercice 3 ................................................................................................................................................................41
Exercice 4 ................................................................................................................................................................41
Exercice 5 ................................................................................................................................................................42
Exercice 6 ................................................................................................................................................................43
Exercice 7 ................................................................................................................................................................43
Exercice 8 ................................................................................................................................................................43
Exercice 9 ................................................................................................................................................................44
TP n3..................................................................................................................................................................................45
Exercice 1 ................................................................................................................................................................45
Exercice 2 ................................................................................................................................................................45
Exercice 3 ................................................................................................................................................................45
Exercice 4 ................................................................................................................................................................45
Exercice 5 ................................................................................................................................................................45
Exercice 6 ................................................................................................................................................................46
Exercice 7 ................................................................................................................................................................46
Exercice 8 ................................................................................................................................................................46
Exercice 9 ................................................................................................................................................................46
Exercice 1 ................................................................................................................................................................47
Exercice 2 ................................................................................................................................................................47
Exercice 3 ................................................................................................................................................................48
Exercice 4 ................................................................................................................................................................48
Exercice 5 ................................................................................................................................................................49
Exercice 6 ................................................................................................................................................................49
Exercice 7 ................................................................................................................................................................50
Exercice 8 ................................................................................................................................................................51
Exercice 9 ................................................................................................................................................................51
TP n4..................................................................................................................................................................................53
Exercice n1 ............................................................................................................................................................54
Exercice n3 ............................................................................................................................................................54
Exercice n4 ............................................................................................................................................................54
Exercice n5 ............................................................................................................................................................54
Exercice n6 ............................................................................................................................................................55
Exercice n7 ............................................................................................................................................................55
Exercice n8 ............................................................................................................................................................55
Exercice n9 ............................................................................................................................................................55
Exercice n10 ..........................................................................................................................................................55
Exercice n11 ..........................................................................................................................................................55
CORRECTION DU TP N4 ..............................................................................................................................................57
Exercice n1 ............................................................................................................................................................57
Exercice n2 ............................................................................................................................................................57
Exercice n3 ............................................................................................................................................................58
Exercice n4 ............................................................................................................................................................58
Exercice n5 ............................................................................................................................................................60
Exercice n6 ............................................................................................................................................................61
Exercice n7 ............................................................................................................................................................61
Exercice n8 ............................................................................................................................................................62
Exercice n9 ............................................................................................................................................................62
Exercice n10 ..........................................................................................................................................................63
Exercice n11 ..........................................................................................................................................................63
TP n5..................................................................................................................................................................................64
Exercice n1 ............................................................................................................................................................64
Exercice n2 ............................................................................................................................................................64
Exercice n3 ............................................................................................................................................................64
Exercice n4 ............................................................................................................................................................64
Exercice n5 ............................................................................................................................................................65
Exercice n1 ............................................................................................................................................................66
Exercice n2 ............................................................................................................................................................66
Exercice n3 ............................................................................................................................................................67
Exercice n4 ............................................................................................................................................................67
4/76
Exercice n5 ............................................................................................................................................................68
Examen session principale (Janvier 2009) .......................................................................................................................69
Correction dexamen session principale...........................................................................................................................70
Examen session de contrle (Juin 2009) ...........................................................................................................................73
Correction dexamen session contrle ..............................................................................................................................74
Bibliographie ......................................................................................................................................................................76
5/76
Chapitre 1
ELEMENTS DE LANGAGE C
Objectifs spcifiques:

Manipuler les types standard.

Dclarer des variables.
Savoir les oprateurs de base du langage c.
Savoir utiliser les Bibliothques.
Savoir afficher et utiliser les formats de sorties des variables.
Savoir crire un programme C, le compiler et l'excuter.
Savoir convertir un type de donnes vers un autre.
1. INTRODUCTION
Le langage C est un langage volu et structur, assez proche du langage machine destin des
applications de contrle de processus (gestion d'entres/sorties, applications temps rel ...).
Le langage C possde assez peu d'instructions, il fait par contre appel des bibliothques, fournies en
plus ou moins grand nombre avec le compilateur.
exemples:
math.h : bibliothque de fonctions mathmatiques

stdio.h : bibliothque d'entres/sorties standard
On ne saurait dvelopper un programme en C sans se munir de la documentation concernant

ces bibliothques.
Les compilateurs Borland C++ ou TurboC++ permettent de compiler et excuter des
programmes c et ils offrent la documentation ncessaire.
2. ETAPES PERMETTANT L'EDITION, LA MISE AU POINT, L'EXECUTION D'UN
PROGRAMME
1- Edition du programme source, l'aide d'un diteur (traitement de textes). Le nom du fichier
contient l'extension .CPP, exemple: EXI_1.CPP (menu edit ).
2- Compilation du programme source, c'est dire cration des codes machine destins au
microprocesseur utilis. Le compilateur indique les erreurs de syntaxe mais ignore les fonctionsbibliothque appeles par le programme.
Le compilateur gnre un fichier binaire, non listable, appel fichier objet: EXI_1.OBJ (commande
compile ).
3- Editions de liens: Le code machine des fonctions-bibliothque est charg, cration d'un fichier
binaire, non listable, appel fichier executable: EXI_1.EXE (commande build all ).
4- Excution du programme (commande flche jaune ).
Les compilateurs permettent en gnral de construire des programmes composs de plusieurs fichiers
sources, d'ajouter un programme des units dj compiles ...
6/76
Exemple 1
#include <stdio.h>
/* bibliotheque d'entrees-sorties standard */
#include <conio.h>
void main()
{
printf("BONJOUR");
/* utilisation d'une fonction-bibliotheque */
printf("Pour continuer frapper une touche...");
getch(); /* Attente d'une saisie clavier */
}
Rsultat aprs compilation et excution:
Le langage C distingue les minuscules, des majuscules. Les mots rservs du langage C doivent tre
crits en minuscules.
On a introduit dans ce programme la notion dinterface homme/machine (IHM).
- Lutilisateur visualise une information sur lcran,
- Lutilisateur, par une action sur le clavier, fournit une information au programme.
Exemple 2
#include <stdio.h>
#include <conio.h>
void main()
{
int a, b, somme ; /* dclaration de 3 variables */
printf("BONJOUR");
a = 10 ; /* affectation* /
b = 50 ; /* affectation */
somme = (a + b)*2 ; /* affectation et oprateurs */
printf("Voici le resultat : %d\n ", somme) ;
}
Dans ce programme, on introduit 3 nouveaux concepts :

- La notion de dclaration de variables : les variables sont les donnes que manipulera le
programme lors de son excution. Ces variables sont ranges dans la mmoire vive de
lordinateur. Elles doivent tre dclares au dbut du programme.
- La notion daffectation, symbolise par le signe =.
- La notion dopration.
3. LES DIFFERENTS TYPES DE VARIABLES
7/76
a) Les entiers
Le langage C distingue plusieurs types d'entiers:
___________________________________________________________
TYPE
DESCRIPTION
TAILLE MEMOIRE
___________________________________________________________
int
unsigned int
entier standard sign

entier positif
4 octets: - 231 n 231-1

4 octets: 0 n 232
short
unsigned short
entier court sign

entier court non sign
2 octets: - 215 n 215-1

2 octets: 0 n 216
char
caractre sign
1 octet : - 27 n 27-1
unsigned char
caractre non sign
1 octet : 0 n 28
_____________________________________________________________
Numration: En dcimal les nombres s'crivent tels que, prcds de 0x en hexadcimal.
exemple: 127 en dcimal s'crit 0x7f en hexadcimal.
Remarque: En langage C, le type char est un cas particulier du type entier:
un caractre est un entier de 8 bits
Exemples:
Les caractres alphanumriques s'crivent entre
Le caractre 'b' a pour valeur 98 (son code ASCII).
Le caractre 22 a pour valeur 22.
Le caractre 127 a pour valeur 127.
Le caractre 257 a pour valeur 1 (ce nombre s'crit sur 9 bits, le bit de poids fort est perdu).
Quelques constantes caractres:
________________________________________________________________
CARACTERE
VALEUR (code ASCII)
NOM ASCII
________________________________________________________________
'\n'
interligne
0x0a
LF
'\t'
tabulation horizontale
0x09
HT
'\v'
tabulation verticale
0x0b
VT
'\r'
retour charriot
0x0d
CR
'\f'
saut de page
0x0c
FF
'\\'
backslash
0x5c
\
'\''
cote
0x2c
'
'\"'
guillemets
0x22
"
_______________________________________________________________
8/76
Exemple 3
#include <stdio.h>
#include <conio.h>
void main()
{
int a, b, calcul ; /* dclaration de 3 variables */
char u, v;
printf("BONJOUR");
a = 10 ; /* affectation* /
b = 50 ; /* affectation */
u = 65 ;
v = A ;
calcul = (a + b)*2 ; /* affectation et oprateurs */
printf( Voici le resultat : %d\n , calcul) ;
printf( 1er affichage de u : %d\n ,u) ;
printf( 2me affichage de v : %c\n ,u) ;
printf( 1er affichage de u: %d\n ,v) ;
printf( 2me affichage de v: %c\n ,v) ;
puts("Pour continuer frapper une touche...");
}
b) Les rels
Un rel est compos - d'un signe - d'une mantisse
- d'un exposant
Un nombre de bits est rserv en mmoire pour chaque lment.
Le langage C distingue 2 types de rels:
_________________________________________________________
TYPE
DESCRIPTION
TAILLE MEMOIRE
_________________________________________________________
float
rel standard
4 octets
double
rel double prcision
8 octets
__________________________________________________________
4. LES INITIALISATIONS
Le langage C permet l'initialisation des variables dans la zne des dclarations:
char c;
est quivalent
char c = 'A';
c = 'A';
int i;
est quivalent
int i = 50;
i = 50;
Cette rgle s'applique tous les nombres, char, int, float ...
9/76
5. SORTIES DE NOMBRES OU DE TEXTE A L'ECRAN

c) LA FONCTION PRINTF
Ce n'est pas une instruction du langage C, mais une fonction de la bibliothque stdio.h.
Exemple: affichage d'un texte:
printf("BONJOUR");
printf("BONJOUR\n");
/* pas de retour la ligne du curseur aprs l'affichage, */

/* affichage du texte, puis retour la ligne du curseur. */
Exemple 4
#include <stdio.h>
#include <conio.h>
void main()
{
printf("BONJOUR ");
printf("IL FAIT BEAU\n"); /* equivalent puts("BONJOUR"; */
printf("BONNES VACANCES");
}
La fonction printf exige l'utilisation de formats de sortie, avec la structure suivante:
printf("%format",nom_de_variable);
Exemple 5 Affichage d'une variable de type char:
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
c =66;
printf("%d\n",c);
/* c est le caractere alphanumerique A */

/* affichage du code ASCII en decimal */
/* et retour la ligne */
printf("%o\n",c);
/* affichage du code ASCII en base huit
printf("%x\n",c);
/* affichage du code ASCII en hexadecimal
printf("%c\n",c);
/* affichage du caractre */
10/76
Affichage multiple de structure:

printf("format1 format2 .... formatn",variable1,variable2, .......,variablen);
Exemple 6
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
c ='A';
/* c est le caractere alphanumerique A */
printf("decimal = %d ASCII = %c\n",c,c);
}
Formats de sortie pour les entiers:

%d
%x
%u
affichage en dcimal (entiers de type int),

affichage en hexadcimal (entiers de type int),
affichage en dcimal (entiers de type unsigned int),
Exercice d'application n1
Soit a et b sont des entiers, a = -21430
b = 4782, calculer et afficher a+b, a-b, a*b, a/b, a%b en
format dcimal, et en soignant linterface homme/machine.
a/b donne le quotient de la division, a%b donne le reste de la division.
Solution
#include <stdio.h>
#include <conio.h>
void main()
{
int a,b;
a= -21430;
b= 4782;
printf("A + B = %d\n",a+b);
printf("A - B = %d\n",a-b);
printf("A x B = %d\n",a*b);
printf("A sur B = %d\n",a/b);
printf("A mod B = %d\n",a%b);
puts("Pour continuer frapper une touche...");
}
11/76
Exercice d'application n2
Soit a et b sont des rels,
a = -21,43
b = 4,782, calculer et afficher a+b, a-b, a*b, a/b, en
soignant linterface homme/machine.
NB : Pour le format de sortie pour les rels c'est : %f
Solution
#include <stdio.h>
#include <conio.h>
void main()
{
float a,b;
a= -21.43;
b= 4.782;
printf("A + B = %f\n",a+b);
printf("A - B = %f\n",a-b);
printf("A x B = %f\n",a*b);
printf("A sur B = %f\n",a/b);
}
d) AUTRES FONCTIONS DE SORTIES
Affichage d'un caractre: La fonction putchar permet d'afficher un caractre:
c tant une variable de type char, l'criture putchar(c); est quivalente printf("%c\n",c);
Affichage d'un texte: La fonction puts permet d'afficher un texte:
l'criture puts("bonjour"); est quivalente printf("bonjour\n");
Il vaut mieux utiliser puts et putchar si cela est possible, ces fonctions, non formates, sont
d'excution plus rapide, et ncessitent moins de place en mmoire lors de leur chargement.
6. LES OPERATEURS
Oprateurs arithmtiques sur les rels: + - * / avec la hirarchie habituelle.
Oprateurs arithmtiques sur les entiers: + - * / (quotient de la division) % (reste de la division)
avec la hirarchie habituelle.
Exemple particulier:
char c,d;
c = 'G';
d = c+'a'-'A';
Les caractres sont des entiers sur 8 bits, on peut donc effectuer des oprations. Sur cet exemple, on
transforme la lettre majuscule G en la lettre minuscule g.
Oprateurs logiques sur les entiers:
& ET | OU ^ OU EXCLUSIF
~ COMPLEMENT A UN
DECALAGE A DROITE.
Exemples:
p = n 3;
p = n 3;
DECALAGE A GAUCHE
/* p est gale n dcal de 3 bits gauche */

/* p est gale n dcal de 3 bits droite */
12/76
INCREMENTATION - DECREMENTATION
Le langage C autorise des critures simplifies pour l'incrmentation et la dcrmentation de
variables:
i = i+1; est quivalent i++;
i = i-1; est quivalent i--;
OPERATEURS COMBINES
Le langage C autorise des critures simplifies lorsqu'une mme variable est utilise de chaque ct
du signe = d'une affectation. Ces critures sont viter lorsque l'on dbute l'tude du langage C car
elles nuisent la lisibilit du programme.
a = a+b;
est quivalent
a+= b;
a = a-b;
est quivalent
a-= b;
a = a & b;
est quivalent
a&= b;
LES DECLARATIONS DE CONSTANTES
Le langage C autorise 2 mthodes pour dfinir des constantes.
1ere mthode: dclaration d'une variable, dont la valeur sera constante pour tout le programme:
Exemple:
void main()
{
const float PI = 3.14159;
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
....
}
Dans ce cas, le compilateur rserve de la place en mmoire (ici 4 octets), pour la variable pi, mais
dont on ne peut changer la valeur.
2me mthode: dfinition d'un symbole l'aide de la directive de compilation #define.
Exemple:
#define PI = 3.14159;
void main()
{
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
....
}
Le compilateur ne rserve pas de place en mmoire. Les constantes dclares par #define s'crivent
traditionnellement en majuscules, mais ce n'est pas une obligation.
7. LES CONVERSIONS DE TYPES
Le langage C permet d'effectuer des oprations de conversion de type: On utilise pour cela l'oprateur
de "cast"().
13/76
Exemple :
#include <stdio.h>
#include <conio.h>
void main()
{
int i=0x1234,j;
char d,e;
float r=89.67,s;
j = (int)r;
s = (float)i;
d = (char)i;
e = (char)r;
printf("Conversion float -> int: %5.2f -> %d\n",r,j);
printf("Conversion int -> float: %d -> %5.2f\n",i,s);
printf("Conversion int -> char: %x -> %x\n",i,d);
printf("Conversion float -> char: %5.2f -> %d\n",r,e);
printf("Pour sortir frapper une touche "); getch();
}
14/76
Chapitre 2
SAISIE DE NOMBRES ET DE CARACTERES AU CLAVIER

Manipuler les fonctions d'entre de base

Savoir la diffrence entre les fonctions d'entre et leurs lieux d'utilisation
1. LA FONCTION GETCH
La fonction getch, appartenant la bibliothque conio.h permet la saisie clavier d'un caractre
alphanumrique. La saisie s'arrte ds que le caractre a t frapp.
On peut utiliser getch de deux faons:
- sans retour de variable au programme:
Exemple:
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");

getch();
- avec retour de variable au programme:

Exemple:
char alpha;
printf("ENTRER UN CARACTERE (ATTENTION PAS DE RETURN) ");
alpha = getch();
printf("\nVOICI CE CARACTERE: %c",alpha);
Les parenthses vides de getch() signifient qu'aucun paramtre n'est pass cette fonction par
le programme.
2. LA FONCTION SCANF
La fonction scanf, appartenant la bibliothque stdio.h, permet la saisie clavier de n'importe quel
type de variable.
Les variables saisir sont formates, le nom de la variable est prcd du symbole & dsignant
l'adresse de la variable.
Exemples:
char alpha;
int i;
float r;
scanf("%c",&alpha);
scanf("%d",&i);
scanf("%x",&i);
scanf("%f",&r);
/* saisie d'un caractre */

/* saisie d'un nombre entier en dcimal */
/* saisie d'un nombre entier en hexadcimal*/
/* saisie d'un nombre rel */
15/76
Remarque: Si l'utilisateur ne respecte pas le format indiqu dans scanf, la saisie est ignore. Aucune
erreur n'est gnre.
char alpha;
scanf("%d",&alpha);
Si l'utilisateur saisie 97 tout va bien, alpha devient le caractre dont le code ASCII vaut 97.
Si l'utilisateur saisie a, sa saisie est ignore.
Exemple:
3. LA FONCTION GETCHAR
La fonction getchar pemet la saisie d'un caractre (char). Elle appartient la bibliothque stdio.h.
Les 2 critures suivantes sont quivalentes:
char c;
printf("ENTRER UN CARACTERE: ");
scanf("%c",&c);
char c;
printf("ENTRER UN CARACTERE: ");
c = getchar();
La fonction getchar est moins gourmande en place mmoire que scanf. Il vaut mieux l'utiliser quand
cela est possible; getchar utilise le flux d'entre exactement comme scanf.
16/76
Chapitre 3
LES STRUCTURES CONDITIONNELLES ET LES BOUCLES

Savoir les structures conditionnelles ainsi que ces diffrentes formes.

Savoir combiner deux ou plusieurs conditions.
Choisir la forme adquate des structures de contrle conditionnelles.
Savoir les structures itratives ainsi que ces diffrentes formes.
Choisir la forme adquate des structures itratives.
1. L'INSTRUCTION SI ... ALORS ... SINON ...
Il s'agit de l'instruction:
si (expression conditionnelle vraie)

alors {BLOC 1 D'INSTRUCTIONS}
sinon {BLOC 2 D'INSTRUCTIONS}
Organigramme:
oui
non
condition
vraie
bloc 1 d'
instructions
bloc 2 d'
instructions
suite du programme
Syntaxe en C:
if (expression)
{
............;
............;
............;
}
else
{
............;
............;
............;
}
/* bloc 1 d'instructions */
/* bloc 2 d'instructions */
17/76
Le bloc "sinon" est optionnel:
si (expression vraie)
alors {BLOC D'INSTRUCTIONS}
oui
non
condition
vraie
bloc d'
instructions
suite du programme
Syntaxe en C:
if (expression)
{
............;
............;
............;
}
/* bloc d'instructions */
Remarque: les {} ne sont pas ncessaires lorsque les blocs ne comportent qu'une seule instruction.
2. LES OPERATEURS LOGIQUES
test d'galit:
if (a==b)
" si a gal b "
test de non galit:
if (a!=b)
" si a diffrent de b "
tests de relation d'ordre:
if (a<b)
if (a<=b)
test de ET LOGIQUE:
if ((expression1) && (expression2))

" si l'expression1 ET l'expression2 sont vraies "
test de OU LOGIQUE
if ((expression1) || (expression2))
" si l'expression1 OU l'expression2 est vraie "
test de NON LOGIQUE
if (!(expression1))
" si l'expression1 est fausse "
18/76
if (a>b)
if (a>=b)
Toutes les combinaisons sont possibles entre ces tests.
Le langage C admet des critures contractes dans les expressions de test:

char reponse;
printf("Voulez-vous jouer ?");
reponse = getchar();
if(reponse == 'o')
else printf("TANT-PIS"\n);
est quivalent
char reponse;
printf("Voulez-vous jouer ?");
if((reponse = getchar()) =='o')
else printf("TANT-PIS"\n);
3. L'INSTRUCTION AU CAS OU ... FAIRE ...
L'instruction switch permet des choix multiples uniquement sur des entiers (int) ou des caractres
(char).
Syntaxe:
switch(variable de type char ou int)
au cas o la variable vaut:
{
case valeur1: ......;
- cette valeur1: executer ce bloc d'instructions.
.......;
break;
valeur2:........;
- cette valeur2: executer ce bloc d'instructions.
........;
break;
.
.
etc ...
.
default: .......;
- aucune des valeurs prcdentes: executer ce bloc
........;
d'instructions, pas de "break" ici.
}
le bloc "default" n'est pas obligatoire.
Linstruction switch correspond une cascade dinstructions if ...else
19/76
Exemple:
Cette instruction est commode pour fabriquer des "menus":
char choix;
printf("LISTE PAR GROUPE TAPER 1\n");
printf("LISTE ALPHABETIQUE TAPER 2\n");
printf("POUR SORTIR TAPER S\n");
printf("\nVOTRE CHOIX: ");
choix = getchar();
switch(choix)
{
case '1': .......;
.......;
break;
case '2': ......;
......;
break;
case 'S': printf("\nFIN DU PROGRAMME ....");
break;
default; printf("\nCE CHOIX N'EST PAS PREVU "); /* pas de break ici */
}
4. LA BOUCLE TANT QUE ... FAIRE ...
tant que (expression vraie)

faire{BLOC D'INSTRUCTIONS}
Organigramme:
oui
condition
vraie
non
bloc d'
instructions
Syntaxe en C:
while (expression)
{
............;
............;
............;
}
20/76
Le test se fait d'abord, le bloc d'instructions n'est pas forcment excut.

Remarque:
les {} ne sont pas ncessaires lorsque le bloc ne comporte qu'une seule instruction.
On peut rencontrer la construction suivante: while (expression); termine par un ; et
sans la prsence du bloc d'instructions. Cette construction signifie: "tant que
l'expression est vraie attendre".
5. L'INSTRUCTION POUR ...

pour (initialisation; condition de continuit vraie;modification)
{BLOC D'INSTRUCTIONS}
Organigramme:
initialisation
condition de
continuit vraie
non
oui
bloc d'instructions
modification
suite du programme
Syntaxe en C:
for(initialisation ; condition de continuit ; modification)
{
............;
............;
............;
}
Remarques:
Les {} ne sont pas ncessaires lorsque le bloc ne comporte qu'une seule instruction.
Les 3 instructions du for ne portent pas forcment sur la mme variable.
Une instruction peut tre omise, mais pas les ;
21/76
Exemples:
for(i = 0 ; i<10 ; i++)

{
............;
............;
............;
}
correspond l'organigramme suivant:

i = 0
non
i < 10
oui
bloc d'instructions
suite du
programme
i=i+1
La boucle
for(;;)
{
............;
............;
............;
}
est une boucle infinie (rptition infinie du bloc d'instructions).

Utilisation de variables diffrentes:
resultat = 0;
for(i = 0 ; resultat<30 ; i++)
{
............;
............;
............;
resultat = resultat + 2*i;
}
Exercice: Ecrire un programme C qui permet de saisir un entier puis calcule sa factoriel.
6. L'INSTRUCTION REPETER ... TANT QUE ...
rpter{BLOC D'INSTRUCTIONS}
tant que (expression vraie)
22/76
Organigramme:
bloc d'
instructions
oui
condition
vraie
non
suite du programme
Syntaxe en C:
do
{
............;
............;
............;
}
while (expression);
Le test se faisant aprs, le bloc est excut au moins une fois.

Remarque: les {} ne sont pas ncessaires lorsque le bloc ne comporte qu'une seule instruction.
23/76
Chapitre 4
LES TABLEAUX ET LES CHAINES DE CARACTERES

Comprendre l'utilisation du type tableau.

Savoir dclarer un tableau.
Manipuler des tableaux une ou deux dimensions.
Manipuler des chanes de caractres.
Manipuler les fonctions sur les chaines de caractres.
1. LES TABLEAUX DE NOMBRES (INT ou FLOAT)

Les tableaux correspondent aux matrices en mathmatiques. Un tableau est caractris par sa
taille et par ses lments.
Les tableaux une dimension:
Exemples:
Dclaration: type nom[dim];
int compteur[10];
float nombre[20];
Utilisation: Un lment du tableau est repr par son indice. En langage C les tableaux
commencent l'indice 0. L'indice maximum est donc dim-1.
Appel:
nom[indice]
Exemples:
compteur[2] = 5;
nombre[i] = 6.789;
printf("%d",compteur[i]);
scanf("%f",&nombre[i]);
Les tableaux plusieurs dimensions:

Tableaux deux dimensions:
Dclaration: type nom[dim1][dim2];
Exemples:
int compteur[4][5];
float nombre[2][10];
Utilisation: Un lment du tableau est repr par ses indices. En langage C les tableaux
commencent aux indices 0. Les indices maximum sont donc dim1-1, dim2-1.
Appel:
nom[indice1][indice2]
Exemples:
compteur[2][4] = 5;
nombre[i][j] = 6.789;
printf("%d",compteur[i][j]);
scanf("%f",&nombre[i][j]);
24/76
2. INITIALISATION DES TABLEAUX

On peut initialiser les tableaux au moment de leur dclaration:
Exemples:
int liste[10] = {1,2,4,8,16,32,64,128,256,528};
float nombre[4] = {2.67,5.98,-8,0.09};
int x[2][3] = {{1,5,7},{8,4,3}}; /* 2 lignes et 3 colonnes */
3. LES CHAINES DE CARACTERES

En langage C, les chanes de caractres sont des tableaux de caractres. Leur manipulation est donc
analogue celle d'un tableau une dimension:
Dclaration: char nom[dim];
Exemple:
char texte[10];
Le compilateur rserve (dim-1) places en mmoire pour la chane de caractres: En effet, il

ajoute toujours le caractre NUL ('\0') la fin de la chane en mmoire.
char TXT[10] = "BONJOUR !";
Affichage l'cran:
On peut utiliser la fonction printf et le format %s:
char texte[10] = "BONJOUR";
printf("VOICI LE TEXTE: %s\n",texte);
On utilisera si possible la fonction puts non formate:
puts(texte);
est quivalent
printf("%s\n",texte);
Saisie: On peut utiliser la fonction scanf et le format %s. Une chane tant un pointeur, on
n'crit pas le symbole &. On utilisera de prfrence la fonction gets non formate.
char texte[10];
printf("ENTRER UN TEXTE: ");
scanf("%s",texte); est quivalent
gets(texte);
25/76
Remarque: scanf ne permet pas la saisie d'une chane comportant des espaces: les caractres saisis
partir de l'espace ne sont pas pris en compte (l'espace est un dlimiteur au mme titre que LF) mais
rangs dans le tampon d'entre. Pour saisir une chane de type "il fait beau", il faut utiliser gets.
A l'issue de la saisie d'une chane de caractres, le compilateur ajoute '\0' en mmoire aprs le dernier
caractre.
4. FONCTIONS SUR LES CHAINES DE CARACTERES
La bibliothque <string> fournit une multitude de fonctions pratiques pour le traitement de chanes
de caractres. Voici quelques fonctions les plus frquemment utilises:
Fonctions pour le traitement de chanes de caractres
strlen(<s>)
fournit la longueur de la chane sans compter le '\0' final
copie <t> vers <s>

ajoute <t> la fin de <s>
compare <s> et <t> lexicographiquement et fournit un rsultat:
ngatif
si <s> prcde <t>
zro
si <s> est gal <t>
positif
si <s> suit <t>
strncpy(<s>, <t>, <n>) copie au plus <n> caractres de <t> vers <s>
strncat(<s>, <t>, <n>) ajoute au plus <n> caractres de <t> la fin de <s>
strcpy(<s>, <t>)
strcat(<s>, <t>)
strcmp(<s>, <t>)
Remarques
Comme le nom d'une chane de caractres reprsente une adresse fixe en mmoire, on ne peut
pas 'affecter' une autre chane au nom d'un tableau:
Il faut bien copier la chane caractre par caractre ou utiliser la fonction strcpy
respectivement strncpy:
strcpy(A, "Hello");
La concatnation de chanes de caractres en C ne se fait pas par le symbole '+' comme en

langage algorithmique ou en Pascal. Il faut ou bien copier la deuxime chane caractre par
caractre ou bien utiliser la fonction strcat ou strncat.
La fonction strcmp est dpendante du code de caractres et peut fournir diffrents rsultats
sur diffrentes machines.
26/76
Chapitre 5
LES FONCTIONS

Comprendre l'intrt des fonctions

Savoir dclarer, programmer et utiliser les fonctions.
1. INTRODUCTION
En langage C les sous-programmes s'appellent des fonctions.
L'imbrication de fonctions n'est pas autorise en C: une fonction ne peut pas tre dclare l'intrieur
d'une autre fonction. Par contre, une fonction peut appeler une autre fonction. Cette dernire doit tre
dclare avant celle qui l'appelle.
Une fonction possde un et un seul point d'entre, mais ventuellement plusieurs points de sortie (
l'aide du mot return).
Une variable connue uniquement d'une fonction ou de main() est une variable locale.
Une variable connue de tout le programme est une variable globale.
2. DECLARATION
On dclare une fonction ainsi :
type nom( type1 arg1 , type2 arg2, ... , typen argn)
{
dclaration variables locales ;
instructions ;
return expression ;
}
type est le type de la valeur renvoye par la fonction. type1 est le type du 1er argument arg1 ....
Les variables locales sont des variables qui ne sont connues qu lintrieur de la fonction.
expression est value lors de linstruction return (expression) ;, cest la valeur que renvoie
la fonction quand elle est appele depuis main().
Exemple de fonction :
float affine( float x ) { /* la fonction affine prend 1 argument rel */
/* et renvoie un argument rel */
int a,b ;
a=3 ;
b=5 ;
return a*x+b ; /* valeur renvoye par la fonction */
}
27/76
3. FONCTIONS SANS PASSAGE D'ARGUMENTS ET NE RENVOYANT RIEN AU

PROGRAMME.
Une fonction ne renvoyant rien au programme est une fonction de type void.
Exemple1
#include <stdio.h>
#include <conio.h>
void bonjour()
/* declaration de la fonction */
{
printf("bonjour\n");
}
void main()
/* programme principal */
{
bonjour(); /* appel de la fonction */
printf("POUR CONTINUER FRAPPER UNE TOUCHE: ");
getch();
}
Dans cette exemple le programme principal appel une fonction bonjour qui se charge
d'affichage du message "Bonjour" mais cette dernire ne renvoie rien en retour.
Exemple 2
#include <stdio.h>
#include <conio.h>
void bonjour()
{
printf("bonjour\n");
}
void coucou()
{
bonjour(); /* appel d'une fonction dans une fonction */
printf("coucou\n");
}
void main()
{
coucou(); /* appel de la fonction */
getch();
}
Dans cette exemple on traite le cas ou une fonction fait appel une autre fonction.
28/76
Exemple 3
#include <stdio.h>
#include <conio.h>
void carre()
{
int n,n2;
/* variables locales carre */
printf("ENTRER UN NOMBRE: ");
scanf("%d",&n);
n2 = n*n ;
printf("VOICI SON CARRE: %d\n",n2);
}
void main()
{
carre(); /* appel de la fonction */
getch();
}
Constatation
Les variables n et n2 ne sont connues que de la fonction carr on les appels des variables locaux.
Exemple 4
#include <stdio.h>
#include <conio.h>
void carre()
{
int n, n2;
/* variables locales a carre */
scanf("%d",&n);
n2 = n*n;
}
void cube()
{
int n, n3;
/* variables locales a cube */
scanf("%d",&n);
n3 = n*n*n;
printf("VOICI SON CUBE: %d\n",n3);
}
void main()
{
char choix;
/* variable locale a main() */
printf("CALCUL DU CARRE TAPER 2 \n");
printf("CALCUL DU CUBE TAPER 3 \n");
scanf("%c",&choix);
29/76
switch(choix)
{
case '2':carre();break;
case '3':cube();break;
}
printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE: ");
getch();
}
Constatations
Les 2 variables locales n sont indpendantes l'une de l'autre.
La variable locale choix n'est connue que de main().
Exemple 5
#include <stdio.h>
#include <conio.h>
int n;
/* variable globale, connue de tout le programme */
void carre()
{
int n2; /* variable locale */
scanf("%d",&n);
n2 = n*n;
}
void cube()
{
int n3; /* variable locale */
scanf("%d",&n);
n3 = n*n*n;
printf("VOICI SON CUBE: %d\n",n3);
}
void main()
{
char choix;
/* variable locale a main() */
printf("CALCUL DU CARRE TAPER 2\n");
printf("CALCUL DU CUBE TAPER 3\n");
scanf("%c",&choix);
switch(choix)
{
case '2':carre();break;
case '3':cube();break;
}
printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE: ");
getch();
}
30/76
Constatations
La variable globale n est connue de tout le programme (fonctions et main()).
La variable locale choix n'est connue que de main().
Le fichier den-tte na pas chang.
Un programme bien construit possde peu de variables globales.
4. FONCTION RENVOYANT UNE VALEUR AU PROGRAMME ET SANS PASSAGE
D'ARGUMENTS
Dans ce cas, la fonction, aprs excution, renvoie une valeur. Le type de cette valeur est dclar avec
la fonction. La valeur retourne est spcifie l'aide du mot rserv return.
Exemple 6
#include <stdio.h>
#include <conio.h>
int TailleTableau() /* declaration de la fonction */
{
int Taille; /* variable locale */
do{
printf("Entre Taille entre 1 et 20 : ");
scanf("%d",&Taille);
}while((Taille>1) && (Taille<=20))
return(Taille);
}
void main()
{
int n;
n= TailleTableau(); /* resultat prend la valeur retournee par le sous-programme */
printf("La Taille saisie est : %d \n",n);
printf("POUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}
5. FONCTIONS AVEC PASSAGE D'ARGUMENTS
Ce paragraphe traite directement du cas gnral: fonctions de type void ou non (renvoyant une valeur
ou non).
Ces fonctions utilisent les valeurs de certaines variables du programme les ayant appel: on passe ces
valeurs au moyen d'arguments dclars avec la fonction.
Exemple 7
#include <stdio.h>
#include <conio.h>
int carre(int x) /* declaration de la fonction */
{
/* x est un parametre*/
int x2; /* variable locale */
x2 = x*x;
return(x2);
}
31/76
void main()
{
int n1, n2, res1, res2;
/* variables locales */
scanf("%d",&n1);
res1 = carre(n1);
printf("ENTRER UN AUTRE NOMBRE: ");
scanf("%d",&n2);
res2 = carre(n2);
printf("VOICI LEURS CARRES: %d %d\n\n",res1, res2);
printf("POUR SORTIR FRAPPER UNE TOUCHE: ");
getch();
}
On peut ainsi appeler la fonction carre autant de fois que l'on veut avec des variables diffrentes.
x est un paramtre, ou argument: ce n'est pas une variable du programme.
S'il y a plusieurs arguments passer, il faut respecter la syntaxe suivante:
Exemples: void fonction1(int x, int y)
void fonction2(int a, float b, char c)
6. RESUME SUR VARIABLES ET FONCTIONS

On a donc vu qu'une variable globale est dclare au dbut du programme et qu'elle est connue de
tout le programme. Les variables globales sont initialises 0 au dbut de l'excution du
programme, sauf si on les initialise une autre valeur.
On a vu aussi qu'une variable locale (dclare au dbut d'une fonction ou de main()) n'est connue que
de cette fonction ou de main(). Une variable locale est encore appele automatique.
Les variables locales ne sont pas initialises (sauf si on le fait dans le programme) et elles perdent
leur valeur chaque appel la fonction.
On peut allonger la dure de vie d'une variable locale en la dclarant static. Lors d'un nouvel appel
la fonction, la variable garde la valeur obtenue la fin de l'excution prcdente. Une variable static
est initialise 0 lors du premier appel la fonction.
Exemple: int i;
devient
static int i;
7. LE PASSAGE DE PARAMETRES ENTRE FONCTIONS OU ENTRE FONCTIONS ET

PROGRAMME PRINCIPAL
En langage C, le passage de paramtre se fait uniquement par adresse. Autrement dit, une fonction
ne peut pas modifier la valeur des variables locales main() ou une autre fonction. Elle ne
peut modifier que le contenu de l'adresse de cette variable.
32/76
Exemple: Fonction permettant d'changer la valeur de 2 variables:

Syntaxe qui conduit une erreur:
#include <stdio.h>
void ech(int x, int y)
{
int tampon;
tampon = x;
x = y;
y = tampon;
}
void main()
{
int a = 5 , b = 8;
ech(a,b);
printf("a=%d\n", a) ;
printf("b=%d\n", b) ;
}
PASSAGE DES PARAMETRES
PAR VALEUR
Syntaxe correcte:
#include <stdio.h>
void ech(int *x, int *y)
{
int tampon;
tampon = *x;
*x = *y;
*y = tampon;
}
void main()
{
int a = 5 , b = 8 ;
ech(&a,&b);
printf("a=%d\n", a) ;
printf("b=%d\n", b) ;
}
PASSAGE DES PARAMETRES
PAR ADRESSE
a et b sont des variables locales main(). La fonction ech ne peut donc pas modifier leur valeur. On
le fait donc en passant par l'adresse de ces variables.
Exprimenter ces deux exemples, noter les rsultats obtenus.
Dans un deuxime temps, afficher dans main() les adresses de a et de b et dans ech les adresses de x
et de y (programme de gauche), les adresses x et y (programme de droite).
Le problme ne se pose pas lorsque le paramtre est un pointeur ou un tableau.
33/76
Anne Universitaire : 2009/2010

Module : Atelier de programmation I
Semestre : 1
Classe : 1re anne LFIAG
Enseignant : Riadh BOUSLIMI
TP n1
Exercice 1
Ecrire un programme qui saisit 2 entiers et affiche successivement la somme, la diffrence, le produit
et le quotient de ces 2 entiers.
Exercice 2
Ecrire un programme qui demande lutilisateur de donner le rayon dun cercle et lui retourne sa
surface et son primtre.
Exercice 3
Ecrire un programme qui saisit deux entiers a et b et permute la valeur de ces deux entiers.
Exercice 4
Ecrire un programme qui saisit un rel x et un entier n et affiche x la puissance n.
Exercice 5
Ecrire un programme qui saisit un caractre c puis affiche son code ASCII en dcimal, en octal(base
huit) et en hexadcimal(base seize).
34/76
Correction du TP n1
Exercice 1
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b;
printf("Entrer deux nombres entiers :");
scanf("%d %d",&a,&b);
printf("\nLa
printf("\nLa
printf("\nLe
printf("\nLe
somme de %d et %d vaut %d",a,b,a+b);

difference de %d et %d vaut %d",a,b,a-b);
produit de %d et %d vaut %d",a,b,a*b);
quotient de %d et %d vaut %f\n",a,b,(float)a/(float)b);

}
Exercice 2
#include<stdio.h>
#include<conio.h>
void main()
{
/* il faut utiliser une variable tampon pour l'echange */
int a,b,tampon;
printf("Entrer 2 entiers a et b:");
scanf("%d %d",&a,&b);
tampon=a;
a=b;
b=tampon;
printf("a vaut maintenant %d\n",a);
printf("b vaut maintenant %d\n",b);
}
Exercice 3
#include<stdio.h>
#include<math.h>
#include<conio.h>
#define Pi 4*atan(1)
void main()
{
float r;
printf("Entrer le rayon du cercle :");
scanf("%f",&r);
printf("La surface du cercle vaut %f \n",Pi*r*r);
printf("Le perimetre du cercle vaut %f\n",2*Pi*r);
}
35/76
Exercice 4
#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{
int n;
float x;
printf("\nEntrer un reel :");
scanf("%f",&x);
printf("Entrer une puissance entiere:");
scanf("%d",&n);
printf("%f a la puissance %d vaut %f\n",x,n,pow(x,n));
}
Exercice 5
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
printf("Entrer un caractre :");
scanf("%c",&c);
printf("%d\n",c);
/* affichage du code ASCII en decimal */

printf("%o\n",c);
/* affichage du code ASCII en base huit
printf("%x\n",c);
/* affichage du code ASCII en hexadecimal
}
36/76

Semestre : 1
re
Classe : 1 anne LFIAG
TP n2
Objectifs de ce TP c'est d'utiliser la forme adquate des structures de contrle conditionnelles pour
rsoudre des problmes.
Exercice 1
Considrez la squence d'instructions suivante:
if (A>B) printf ("premier choix \n");else
if (A>10) printf ("deuxime choix \n");
if (B<10) printf ("troisime choix \n");
else printf ("quatrime choix \n");
a) Copiez la squence d'instructions en utilisant des tabulateurs pour marquer les blocs if - else
appartenant ensemble.
b) Dterminez les rponses du programme pour chacun des couples de nombres suivants et
vrifiez l'aide de l'ordinateur.
A=10 et B=5
A=5 et B=5
A=5 et B=10
A=10 et B=10
A=20 et B=10
A=20 et B=20
37/76
Exercice 2
if (A>B)
if (A>10)
printf ("premier choix \n"); else if (B<10)
printf ("deuxime choix \n"); else
if (A==B) printf ("troisime choix \n");
b) Pour quelles valeurs de A et B obtient-on les rsultats:
premier choix, deuxime choix, ... sur l'cran?
c) Pour quelles valeurs de A et B n'obtient-on pas de rponse sur l'cran?
d) Notez vos rponses et choisissez vous-mmes des valeurs pour A et B pour les vrifier l'aide
de l'ordinateur.
Exercice 3
Ecrivez un programme qui saisit un caractre, et qui teste s'il s'agit d'une lettre majuscule, si oui il
renvoie cette lettre en minuscule, sinon il renvoie un message d'erreur.
Exercice 4
Ecrivez un programme qui lit trois valeurs entires (A, B et C) au clavier et qui affiche la plus grande
des trois valeurs, en utilisant:
a) if - else et une variable d'aide MAX
b) if - else if - ... - else sans variable d'aide
c) les oprateurs conditionnels et une variable d'aide MAX
d) les oprateurs conditionnels sans variable d'aide
Exercice 5
Ecrivez un programme qui lit trois valeurs entires (A, B et C) au clavier. Triez les valeurs A, B et C
par changes successifs de manire obtenir :
val(A) val(B) val(C)
Affichez les trois valeurs.
Exercice 6
Ecrivez un programme qui lit deux valeurs entires (A et B) au clavier et qui affiche le signe du
produit de A et B sans faire la multiplication.
Exercice 7
Ecrivez un programme qui lit deux valeurs entires (A et B) au clavier et qui affiche le signe de la
somme de A et B sans faire l'addition. Utilisez la fonction fabs de la bibliothque <math.h> qui
renvoie la valeur absolue d'un flottant.
38/76
Exercice 8
Ecrivez un programme qui calcule les solutions relles d'une quation du second degr ax2+bx+c =
0 en discutant la formule:
Utilisez une variable d'aide D pour la valeur du discriminant b2-4ac et dcidez l'aide de D, si
l'quation a une, deux ou aucune solution relle.
Utilisez des variables du type int pour A, B et C.
Considrez aussi les cas o l'utilisateur entre des valeurs nulles pour A; pour A et B; pour A, B et C.
Affichez les rsultats et les messages ncessaires sur l'cran.
Exercice 9
Ecrivez un programme qui permet de saisir un entier entre 1 et 7 et affiche en toutes lettres le nom du
jour de la semaine qui lui correspond.
39/76
Correction du TP n2
Exercice 1
if (A>B) printf ("premier choix \n"); else
if (A>10) printf ("deuxime choix \n");
if (B<10) printf ("troisime choix \n");
if (A>B)
printf ("premier choix \n");
else
if (A>10)
printf ("deuxime choix \n");
if (B<10)
printf ("troisime choix \n");
else
printf ("quatrime choix \n");
b) Dterminez les rponses du programme pour chacun des couples de nombres suivants et
vrifiez l'aide de l'ordinateur.
A=10 et B=5 : premier choix
troisime choix
A=5 et B=5 :
troisime choix
A=5 et B=10 :
quatrime choix
A=10 et B=10 :
quatrime choix
A=20 et B=10 :
premier choix
quatrime choix
A=20 et B=20 :
deuxime choix
quatrime choix
Exercice 2
if (A>B)
if (A>10)
printf ("premier choix \n"); else if (B<10)
printf ("deuxime choix \n"); else
if (A==B) printf ("troisime choix \n");
if (A>B)
if (A>10)
printf ("premier choix \n");
else if (B<10)
printf ("deuxime choix \n");
else if (A==B)
printf ("troisime choix \n");
else
printf ("quatrime choix \n");
40/76
b) Le rsultat:
"premier choix"
apparat pour (A>B) et (A>10)
"deuxime choix"
apparat pour (10A>B)
"troisime choix"
apparat pour (10A>B10) et (A=B)

10>10 impossible
A>B et A=B impossible
"quatrime choix"
=> "troisime choix" n'apparat jamais
apparat pour (10A>B10) et (AB)

10>10 impossible
=> "quatrime choix" n'apparat jamais
c) On n'obtient pas de rponses pour (AB). Si (A>B) alors la construction if - else if - ... - else
garantit que toutes les combinations sont traites et fournissent un rsultat.
Exercice 3
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
printf("ENTRER UNE LETTRE:");
c = getchar();
if((c>='A') && (c<='Z'))
printf("CETTE LETTRE EN MINUSCULE: %c\n",c);
else
printf("CE N'EST PAS UNE LETTRE MAJUSCULE\n");
getch();
}
Exercice 4
a) if - else et une variable d'aide MAX
#include <stdio.h>
#include <conio.h>
void main()
{
int A, B, C;
int MAX;
printf("Introduisez trois nombres entiers :");
scanf("%d %d %d", &A, &B, &C);
if (A>B)
MAX=A;
else
MAX=B;
if (C>MAX)
MAX=C;
printf("La valeur maximale est %d\n", MAX);
printf("Tapez une touche pour continuer");
getch();
}
41/76
b) if - else if - ... - else sans variable d'aide

int A, B, C;
scanf("%d %d %d", &A, &B, &C);
printf("La valeur maximale est ");
if (A>B && A>C)
printf("%d\n",A);
else if (B>C)
printf("%d\n",B);
else
printf("%d\n",C);
c) oprateurs conditionnels et une variable d'aide MAX

int A, B, C;
int MAX;
scanf("%d %d %d", &A, &B, &C);
MAX = (A>B) ? A : B;
MAX = (MAX>C) ? MAX : C;
printf("La valeur maximale est %i\n", MAX);
d) oprateurs conditionnels sans variable d'aide

int A, B, C;
scanf("%d %d %d", &A, &B, &C);
printf("La valeur maximale est %d\n",
(A>((B>C)?B:C)) ? A : ((B>C)?B:C));
Exercice 5
#include <stdio.h>
#include <conio.h>
void main()
{
/* Tri par ordre dcroissant de trois entiers
en changeant les valeurs
*/
int A, B, C, AIDE;
scanf("%d %d %d", &A, &B, &C);
printf("Avant le tri : \tA = %d\tB = %d\tC = %d\n", A, B, C);
/* Valeur maximale -> A */
if (A<B)
{
AIDE = A;
A = B;
B = AIDE;
}
if (A<C)
{
AIDE = A;
A = C;
C = AIDE;
}
/* trier B et C */
if (B<C)
{
AIDE = B;
B = C;
C = AIDE;
}
printf("Aprs le tri : \tA = %d\tB = %d\tC = %d\n", A, B, C);
getch();
}
42/76
Exercice 6
#include <stdio.h>
#include <conio.h>
void main()
{
/* Afficher le signe du produit de deux entiers sans
faire la multiplication
*/
int A, B;
printf("Introduisez deux nombres entiers :");
scanf("%d %d", &A, &B);
if ((A>0 && B>0) || (A<0 && B<0))
printf("Le signe du produit %d * %d est positif\n", A, B);
else if ((A<0 && B>0) || (A>0 && B<0))
printf("Le signe du produit %d * %d est ngatif\n", A, B);
else
printf("Le produit %d * %d est zro\n", A, B);
getch();
}
Exercice 7
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main()
{
/* Afficher le signe de la somme de deux entiers sans
faire l'addition
*/
int A, B;
printf("Introduisez deux nombres entiers :");
scanf("%d %d", &A, &B);
if ((A>0 && B>0) || (A<0 && B>0 && fabs(A)<fabs(B))
|| (A>0 && B<0 && fabs(A)>fabs(B)))
printf("Le signe de la somme %d + %d est positif\n",A,B);
else if ((A<0 && B<0) || (A<0 && B>0 && fabs(A)>fabs(B))
|| (A>0 && B<0 && fabs(A)<fabs(B)))
printf("Le signe de la somme %d + %d est ngatif\n",A,B);
else
printf("La somme %d + %d est zro\n", A, B);
printf("\n Tapez une touche pour continuer");
getch();
}
Exercice 8
#include <stdio.h>
#include <conio.h>
#include <math.h>
void main()
{
/* Calcul des solutions relles d'une quation du second degr */
int A, B, C;
float D; /* Discriminant */
printf("Calcul des solutions relles d'une quation du second \n");
printf("degr de la forme
ax^2 + bx + c = 0 \n\n");
printf("Introduisez les valeurs pour a, b, et c : ");
scanf("%d %d %d", &A, &B, &C);
/* Calcul du discriminant b^2-4ac */
D = pow(B,2) - 4.0*A*C;
43/76
/* Distinction des diffrents cas */

if (A==0 && B==0 && C==0) /* 0x = 0 */
printf("Tout rel est une solution de cette quation.\n");
else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */
printf("Cette quation ne possde pas de solutions.\n");
else if (A==0) /* bx + c = 0 */
{
printf("La solution de cette quation du premier degr est :\n");
printf(" x = %f\n", -C/B);
}
else if (D<0) /* b^2-4ac < 0 */
printf("Cette quation n'a pas de solutions relles.\n");
else if (D==0) /* b^2-4ac = 0 */
{
printf("Cette quation a une seule solution relle :\n");
printf(" x = %f\n", -B/(2*A));
}
else /* b^2-4ac > 0 */
{
printf("Les solutions relles de cette quation sont :\n");
printf(" x1 = %f\n", (-B+sqrt(D))/(2*A));
printf(" x2 = %f\n", (-B-sqrt(D))/(2*A));
}
printf("\n tapez une touche pour continuer");
getch();
}
Exercice 9
#include <stdio.h>
#include <conio.h>
void main()
{
int N;
string jour[];
printf("Introduisez le numro du jour entre 1 et 7 :");
scanf("%d", &N);
switch(N)
{
case 1: jour="Lundi";break;
case 2: jour="Mardi";break;
case 3: jour="Mercredi";break;
case 4: jour="Jeudi";break;
case 5: jour="Vendredi";break;
case 6: jour="Samedi";break;
case 7: jour="Dimanche";break;
default: printf("\n Jour Incorrect");
}
/* pas de break ici */
printf("Le jour de la semaine de %d est %s :", N, jour);

getch();
}
44/76

Semestre : 1
re
Classe : 1 anne LFIAG
TP n3
Objectifs de ce TP c'est la manipulation des structures itratives et savoir distinguer entre les
diffrentes formes (structure itrative complte et structure itrative condition d'arrt).
Exercice 1
Saisir une suite de caractres, compter et afficher le nombre de lettres e et d'espaces. Utiliser les
proprits du tampon.
Exercice 2
Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme, leur produit et
leur moyenne. Choisissez un type appropri pour les valeurs afficher. Le nombre N est entrer au
clavier. Rsolvez ce problme,
a) en utilisant while,
b) en utilisant do - while,
c) en utilisant for.
Exercice 3
Calculez par des soustractions successives le quotient entier et le reste de la division entire de deux
entiers entrs au clavier.
Exercice 4
Calculez par multiplications successives XN de deux entiers naturels X et N entrs au clavier.
Exercice 5
Calculez la somme des N premiers termes de la srie harmonique :
1 + 1/2 + 1/3 + ... + 1/N
45/76
Exercice 6
Calculez la somme, le produit et la moyenne d'une suite de chiffres non nuls entrs au clavier, sachant
que la suite est termine par zro. Retenez seulement les chiffres (0, 1 ... 9) lors de l'entre des
donnes et effectuez un signal sonore si les donnes sortent de ce domaine.
Exercice 7
Calculez le nombre lu rebours d'un nombre positif entr au clavier en supposant que le fichier
d'entre standard contient une suite de chiffres non nuls, termine par zro (Contrlez s'il s'agit
vraiment de chiffres).
Exemple: Entre: 1 2 3 4 0
Affichage: 4321
Exercice 8
Calculez le nombre lu rebours d'un nombre positif entr au clavier en supposant que le fichier
d'entre standard contient le nombre inverser.
Exemple: Entre: 1234
Affichage: 4321
Exercice 9
Calculez le N-ime terme UN de la suite de FIBONACCI qui est donne par la relation de rcurrence:
U1=1 U2=1 UN=UN-1 + UN-2 (pour N>2)
Dterminez le rang N et la valeur UN du terme maximal que l'on peut calculer si on utilise pour UN le
type int.
46/76
Correction du TP n3
Exercice 1
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
int compt_espace= 0,compt_e= 0;
printf("ENTRER UNE PHRASE:\n");
while((c=getchar())!='\n')
{
if(c=='e')compt_e++;
/*
/*
/*
/*
/*
*/
*/
*/
et recuperes par getchar lors */
des autres passages */
lors du 1er passage, getchar ne prend

en compte que le 1er caractere
les autres sont ranges dans le tampon
if(c==' ')compt_espace++;
}
printf("NOMBRE DE e: %d\n",compt_e);
printf("NOMBRE D'ESPACE: %d\n",compt_espace);
printf("POUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}
Exercice 2
a) en utilisant while,
#include <stdio.h>
#include <conio.h>
void main()
{
int N;
/* nombre de donnes */
int NOMB;
/* nombre courant
*/
int I;
/* compteur */
long SOM;
/* la somme
des nombres entrs */
double PROD; /* le produit des nombres entrs */
printf("Nombre de donnes : ");
scanf("%d", &N);
SOM=0;
PROD=1;
I=1;
while(I<=N)
{
printf("%d. nombre : ", I);
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
I++;
}
printf("La somme
des
printf("Le produit des
printf("La moyenne des
printf("POUR CONTINUER
getch();
%d nombres est %ld \n", N, SOM);

%d nombres est %f\n", N, PROD);
%d nombres est %f\n", N, (float)SOM/N);
FRAPPER UNE TOUCHE ");
b) en utilisant do - while, Remplacez le bloc de traitement (en gras) de (a) par :

SOM=0;
PROD=1;
I=1;
do
47/76
{
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
I++;
}
while(I<=N);
c) en utilisant for.
Remplacez le bloc de traitement (en gras) de (a) par :
for (SOM=0, PROD=1, I=1 ; I<=N ; I++)
{
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
}
Exercice 3
#include <stdio.h>
#include <conio.h>
void
{
int
int
int
int
main()
NUM;
DEN;
DIV;
RES;
/*
/*
/*
/*
numrateur
de la division entire */
dnominateur de la division entire */
rsultat de la division entire */
reste
de la division entire */
printf("Introduisez le numrateur
: ");
scanf("%d", &NUM);
printf("Introduisez le dnominateur : ");
scanf("%d", &DEN);
RES=NUM;
DIV=0;
while(RES>=DEN)
{
RES-=DEN;
DIV++;
}
/* ou mieux encore : */
for (RES=NUM, DIV=0 ; RES>=DEN ; DIV++)
RES-=DEN;
*/
printf(" %d divis par %d est %d reste %d\n", NUM, DEN, DIV, RES);
getch();
}
Exercice 4
#include <stdio.h>
#include <conio.h>
void main()
{
int X, N;
/* Les donnes */
int I;
/* Le compteur */
double RESU; /* Type double cause de la */
/* grandeur du rsultat.
*/
do
{
printf("Entrez l'entier naturel X : ");
scanf("%d", &X);
}
while (X>=0);
48/76
do
{
printf("Entrez l'exposant
scanf("%d", &N);
N : ");
}
while (N<0);
/* Pour N=0, le rsultat sera automatiquement X^0=1 */
for (RESU=1.0, I=1 ; I<=N ; I++)
RESU*=X;
/* Attention: Pour X=0 et N=0 , 0^0 n'est pas dfini */
if (N==0 && X==0)
printf("zro exposant zro n'est pas dfini !\n");
else
printf("Rsultat : %d ^ %d = %.0f\n", X, N, RESU);
getch();
}
Exercice 5
#include <stdio.h>
#include <conio.h>
void main()
{
int N;
/* nombre de termes calculer */
int I;
/* compteur pour la boucle */
float SOM; /* Type float cause de la prcision du rsultat.
do
{
printf ("Nombre de termes: ");
scanf ("%d", &N);
}
while (N>=1);
for (SOM=0.0, I=1 ; I<=N ; I++)
SOM += (float)1/I;
printf("La somme des %d premiers termes est %f \n", N, SOM);
getch();
}
Exercice 6
Solution (une de plusieurs solutions possibles) :
#include <stdio.h>
#include <conio.h>
void main()
{
int X;
int N=0;
int SOM=0;
long PROD=1;
/*
/*
/*
/*
/*
Le chiffre courant
*/
Le compteur des donnes */
La somme actuelle
*/
Le produit actuel - Type long */
cause de la grandeur du rsultat. */
49/76
*/
do
{
/* Saisie des donnes (pour perfectionnistes) */
printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
scanf("%d", &X);
if (X<0||X>9)
printf("\a");
else if (X)
{
N++;
SOM+=X;
PROD*=X;
}
else if (!X && N>0)
{/* Seulement si au moins un chiffre a t accept */
printf("La somme
des chiffres est %d \n", SOM);
printf("Le produit des chiffres est %ld\n", PROD);
printf("La moyenne des chiffres est %f \n", (float)SOM/N);
}
}
while (X);
getch();
}
Exercice 7
#include <stdio.h>
#include <conio.h>
void main()
{
int X;
int N=0;
long VALD=1;
long NOMB=0;
/*
/*
/*
/*
Le chiffre courant
*/
Le compteur des dcimales */
Valeur de la position dcimale courante */
Le nombre rsultat
*/
do
{
printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
scanf("%d", &X);
if (X>=0 && X<=9)
printf("\a");
else if (X)
{
NOMB += VALD*X;
N++;
VALD *= 10;
}
else
printf("La valeur du nombre renvers est %ld\n", NOMB);
}
while (X);
getch();
}
Remarque :
En remplaant la ligne
NOMB += VALD*X;
par
50/76
NOMB += pow(10, N)*X;
on n'a plus besoin de la variable VALD. Il faut cependant inclure les fonctions de la bibliothque
<math>. D'autre part, le calcul de 10N serait alors rpt chaque excution de la boucle.
Finalement, cette variante est plus lente et plus volumineuse que la premire.
Exercice 8
#include <stdio.h>
#include <conio.h>
void main()
{
int NOMB;
/* Le nombre inverser */
int NINV;
/* Le nombre invers
*/
/* Attention: en utilisant le type int, il est impossible */
/* d'inverser correctement des nombres comme 10033 ...
*/
do
{
printf("Entrez un nombre positif (<10000) : ", NOMB);
scanf("%d", &NOMB);
}
while (NOMB<0 || NOMB>9999);
NINV=0;
while(NOMB>0)
{
NINV *= 10;
NINV += NOMB%10;
NOMB /= 10;
}
/* Autre possibilit : */
/* for (NINV=0 ; NOMB>0 ; NOMB/=10)
NINV = NINV*10 + NOMB%10;
*/
printf("Le nombre 'invers' est : %d\n", NINV);
getch();
}
Exercice 9
#include <stdio.h>
#include <conio.h>
void
{
int
int
int
do
{
main()
U1, U2, UN;
N;
I;
/* pour parcourir la suite */

/* rang du terme demand
*/
/* compteur pour la boucle */
printf("Rang du terme demand : ");

scanf("%d", &N);
}
while(N<1);
U1=U2=1; /* Initialisation des deux premiers termes */
if (N==1)
UN=U1;
else if (N==2)
UN=U2;
else{
for (I=3 ; I<=N ; I++)
{
UN = U1+U2;
U1 = U2;
51/76
U2 = UN;
}
}
printf("Valeur du terme de rang %d : %d\n", N, UN);
getch();
}
Rang et terme maximal calculable en utilisant les dclarations :

int U1, U2, UN; (spc. de format : %d) U23 = 28657
52/76

Semestre : 1
TP n4
Objectifs de ce TP c'est la manipulation des tableaux et les chanes de caractres, et utiliser les
fonctions prdfinies pour rsoudre des problmes.
Ce qu'il faut retenir

Bibliothque (string.h):
void *strcat(char *chaine1, char *chaine2)

concatne les 2 chanes, rsultat dans chaine1,

renvoie l'adresse de chaine1.
int strlen(char *chaine)
renvoie la longueur de la chaine ('\0' non comptabilis).
void *strrev(char *chaine)
inverse la chane et, renvoie l'adresse de la chaine inverse.
int strcmp(char *chaine1,char *chaine2)
renvoie un nombre:
o positif si la chane1 est suprieure la chaine2 (au sens de l'ordre alphabtique)
o ngatif si la chane1 est infrieure la chane2
o nul si les chanes sont identiques.
void *strcpy(char *chaine1,char *chaine2)
recopie chaine2 dans chaine1 et renvoie l'adresse de chane1.
Ces fonctions renvoient l'adresse de l'information recherche en cas de succs, sinon le pointeur NULL (c'est dire le
pointeur de valeur 0 ou encore le pointeur faux).

void *strchr(chaine,caractre)
void *strrchr(chaine,caractre)
void *strstr(chane,sous-chane)
recherche le caractre dans la chane.

idem en commenant par la fin.
recherche la sous-chaine dans la chane.
Bibliothque (stdlib.h):

int atoi(char *chane)

float atof(char *chaine)
exemple:
convertit la chane en entier

convertit la chane en rel

gets(texte);
n = atoi(texte) ;
printf("%d",n); /* affiche 123 si texte vaut "123" */
/* affiche 0 si texte vaut "bonjour" */
53/76
void *itoa(int n,char *chane,int base) convertit un entier en chane:

base: base dans laquelle est exprim le nombre,
cette fonction renvoie l'adresse de la chane.
exemple:
itoa(12,texte,10);
texte vaut "12"
Exercice n1
crire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50
composantes), remplit le tableau par des valeurs entres au clavier et affiche le tableau. Calculer et
afficher ensuite la somme des lments du tableau.
Exercice n2
crire un programme qui calcule le produit scalaire de deux vecteurs d'entiers U et V (de mme
dimension).
Exemple:
/
| 3
\
\
/
-4 | * | 2
/
\
-3
\
5 | = 3*2+2*(-3)+(-4)*5 = -20
/
Exercice n3
crire un programme qui dtermine la plus grande et la plus petite valeur dans un tableau d'entiers
A. Afficher ensuite la valeur et la position du maximum et du minimum. Si le tableau contient
plusieurs maxima ou minima, le programme retiendra la position du premier maximum ou
minimum rencontr.
Exercice n4
Problme: Rechercher dans un tableau d'entiers A une valeur VAL entre au clavier. Afficher la
position de VAL si elle se trouve dans le tableau, sinon afficher un message correspondant. La
valeur POS qui est utilise pour mmoriser la position de la valeur dans le tableau, aura la valeur 1 aussi longtemps que VAL n'a pas t trouve.
Implmenter deux versions:
a) La recherche squentielle
Comparer successivement les valeurs du tableau avec la valeur donne.
b) La recherche dichotomique
Condition: Le tableau A doit tre tri
Comparer le nombre recherch la valeur au milieu du tableau,
s'il y a galit ou si le tableau est puis, arrter le traitement avec un message
correspondant.
si la valeur recherche prcde la valeur actuelle du tableau, continuer la recherche
dans le demi-tableau gauche de la position actuelle.
si la valeur recherche suit la valeur actuelle du tableau, continuer la recherche dans le
demi-tableau droite de la position actuelle.
crire le programme pour le cas o le tableau A est tri par ordre croissant.
Question: Quel est l'avantage de la recherche dichotomique ?
Exercice n5
Ecrire un programme qui demande l'introduction du nom et du prnom de l'utilisateur et qui
affiche alors la longueur totale du nom sans compter les espaces. Employer la fonction strlen.
54/76
Exemple:
Introduisez votre nom et votre prnom: HSINI Sana
Bonjour HSINI Sana !
Votre nom est compos de 9 lettres.
Exercice n6
crire un programme qui lit 5 mots, spars par des espaces et qui les affiche ensuite dans une
ligne, mais dans l'ordre inverse.
Les mots sont mmoriss dans 5 variables M1, ... ,M5.
Exemple
voici une petite phrase !
! phrase petite une voici
Exercice n7
crire un programme qui lit une ligne de texte (ne dpassant pas 200 caractres) la mmorise dans
une variable TXT et affiche ensuite:
a) la longueur L de la chane.
b) le nombre de 'e' contenus dans le texte.
c) toute la phrase rebours, sans changer le contenu de la variable TXT.
d) toute la phrase rebours, aprs avoir invers l'ordre des caractres dans TXT:
Exemple :
voici une petite phrase !
! esarhp etitep enu iciov
Exercice n8
Ecrire un programme qui lit un texte TXT (de moins de 200 caractres) et qui enlve toutes les
apparitions du caractre 'e' en tassant les lments restants. Les modifications se feront dans la
mme variable TXT.
Exemple:
Cette ligne contient quelques lettres e.
Ctt lign contint qulqus lttrs .
Exercice n9
Ecrire un programme qui lit un verbe rgulier en "er" au clavier et qui en affiche la conjugaison au
prsent de l'indicatif de ce verbe. Contrlez s'il s'agit bien d'un verbe en "er" avant de conjuguer.
Utiliser les fonctions gets, puts, strcat et strlen.
Exemple:
Verbe : fter
je fte tu ftes
il fte
nous ftons
vous ftez
ils ftent
Exercice n10
Ecrire un programme qui lit deux chanes de caractres CH1 et CH2, les compare
lexicographiquement et affiche le rsultat:
Exemple:
Introduisez la premire chane: ABC
Introduisez la deuxime chane: abc
"ABC" prcde "abc"
Exercice n11
55/76
crire un programme qui permet de vrifier si un mot saisit est un palindrome. Un mot est dit
palindrome si la lecture du mot se fait gauche et droite. La taille maximale du mot est 30
caractres. Exemple : aziza
56/76
CORRECTION DU TP N4
Exercice n1
#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int T[50]; /* tableau donn */
int N;
/* dimension
*/
int I;
/* indice courant */
long SOM; /* somme des lments - type long cause */
/* de la grandeur prvisible du rsultat. */
/* Saisie des donnes */
do{
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
}while(N>=1 && N<=50);
for (I=0; I<N; I++)
{
printf("Elment %d : ", I);
scanf("%d", &T[I]);
}
/* Affichage du tableau */
printf("Tableau donn :\n");
for (I=0; I<N; I++)
printf("%d ", T[I]);
printf("\n");
/* Calcul de la somme */
for (SOM=0, I=0; I<N; I++)
SOM += T[I];
/* Edition du rsultat */
printf("Somme de lments : %ld\n", SOM);
getch();
}
Exercice n2
#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int U[50], V[50]; /* tableaux donns */
int N;
/* dimension
*/
int I;
/* indice courant
*/
long PS;
/* produit scalaire */
do{
scanf("%d", &N );
}while(N>=1 && N<=50);
printf("** Premier tableau **\n");
for (I=0; I<N; I++)
{
scanf("%d", &U[I]);
}
printf("** Deuxime tableau **\n");
for (I=0; I<N; I++)
{
57/76
scanf("%d", &V[I]);
}
/* Calcul du produit scalaire */
for (PS=0, I=0; I<N; I++)
PS += (long)U[I]*V[I];
printf("Produit scalaire : %ld\n", PS);
getch();
}
Exercice n3
#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int N;
/* dimension
*/
int I;
int MIN;
/* position du minimum */
int MAX;
/* position du maximum */
do{
scanf("%d", &N );
}while(N>=1 && N<=50);
for (I=0; I<N; I++)
{
scanf("%d", &A[I]);
}
printf("Tableau donn :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Recherche du maximum et du minimum */
MIN=0;
MAX=0;
for (I=0; I<N; I++)
{
if(A[I]>A[MAX]) MAX=I;
if(A[I]<A[MIN]) MIN=I;
}
printf("Position du minimum : %d\n", MIN);
printf("Position du maximum : %d\n", MAX);
printf("Valeur
du minimum : %d\n", A[MIN]);
printf("Valeur
du maximum : %d\n", A[MAX]);
getch();
}
Exercice n4
a) La recherche squentielle :
Comparer successivement les valeurs du tableau avec la valeur donne.
#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int VAL;
/* valeur rechercher
*/
int POS;
/* position de la valeur */
58/76
int N;
int I;
/* dimension
*/

do{
scanf("%d", &N );
}while(N>=1 && N<=50);
for (I=0; I<N; I++)
{
scanf("%d", &A[I]);
}
printf("Elment rechercher : ");
scanf("%d", &VAL );
printf("Tableau donn : \n");
for (I=0; I<N; I++)
printf("\n");
/* Recherche de la position de la valeur */
POS = -1;
for (I=0 ; (I<N)&&(POS==-1) ; I++)
if (A[I]==VAL)
POS=I;
if (POS==-1)
printf("La valeur recherche ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur %d se trouve la position %d. \n", VAL, POS);
getch();
}
b) La recherche dichotomique
#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int VAL;
/* valeur rechercher
*/
int POS;
/* position de la valeur */
int N;
/* dimension
*/
int I;
int INF, MIL, SUP; /* limites du champ de recherche */
do{
scanf("%d", &N );
}while(N>=1 && N<=50);
for (I=0; I<N; I++)
{
scanf("%d", &A[I]);
}
printf("Elment rechercher : ");
scanf("%d", &VAL );
printf("Tableau donn : \n");
for (I=0; I<N; I++)
printf("\n");
/* Initialisation des limites du domaine de recherche */
INF=0;
SUP=N-1;
/* Recherche de la position de la valeur */
59/76
POS=-1;
while ((INF<=SUP) && (POS==-1))
{
MIL=(SUP+INF)/2;
if (VAL < A[MIL])
SUP=MIL-1;
else if (VAL > A[MIL])
INF=MIL+1;
else
POS=MIL;
}
if (POS==-1)
printf("La valeur recherche ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur %d se trouve la position %d. \n", VAL, POS);
getch();
}
Question: Quel est l'avantage de la recherche dichotomique?

Dans le pire des cas d'une recherche squentielle, il faut traverser tout le tableau avant de trouver la
valeur ou avant d'tre sr qu'une valeur ne se trouve pas dans le tableau.
Lors de la recherche dichotomique, on limine la moiti des lments du tableau chaque excution
de la boucle. Ainsi, la recherche se termine beaucoup plus rapidement.
La recherche dichotomique devient extrmement avantageuse pour la recherche dans de grands
tableaux (tris) : L'avantage de la recherche dichotomique par rapport la recherche squentielle
monte alors exponentiellement avec la grandeur du tableau trier.
Exemple:
Lors de la recherche dans un tableau de 1024 lments:
- le pire des cas pour la recherche squentielle peut entraner 1024 excutions de la boucle.
- le pire des cas pour la recherche dichotomique peut entraner 10 excutions de la boucle.
Lors de la recherche dans un tableau de 1 048 576 lments:
- le pire des cas pour la recherche squentielle peut entraner 1 048 576 excutions de la boucle.
- le pire des cas pour la recherche dichotomique peut entraner 20 excutions de la boucle.
Exercice n5
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main(){
{
char NOM[40], PRENOM[40];
printf("Introduisez votre nom et votre prnom: \n");
scanf("%s %s", NOM, PRENOM);
printf("\nBonjour %s %s !\n", NOM, PRENOM);
printf("Votre nom est compos de %d lettres.\n",
strlen(NOM) + strlen(PRENOM));
/* ou bien
printf("Votre nom est compos de %d lettres.\n",
strlen(strcat(NOM,PRENOM)));
*/
printf("Tapez une touche pour continuer...");
getch();
60/76
Exercice n6
#include <stdio.h>
#include <conio.h>
void main()
{
char M1[30], M2[30], M3[30], M4[30], M5[30];
printf("Entrez 5 mots, spars par des espaces :\n");
scanf ("%s %s %s %s %s", M1, M2, M3, M4, M5);
printf("%s %s %s %s %s\n",M5, M4, M3, M2, M1);
getch();
}
Exercice n7
#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
char TXT[201]; /* chane donne
*/
int I,J; /* indices courants
*/
int L;
/* longueur de la chane
*/
int C;
/* compteur des lettres 'e' */
int AIDE; /* pour l'change des caractres */
printf("Entrez une ligne de texte (max.200 caractres) :\n");
gets(TXT); /* L'utilisation de scanf est impossible pour */
/* lire une phrase contenant un nombre variable de mots. */
/* a) Compter les caractres */
/* La marque de fin de chane '\0' est */
/* utilise comme condition d'arrt. */
for (L=0; TXT[L]; L++)
;
printf("Le texte est compos de %d caractres.\n",L);
/* b) Compter les lettres 'e' dans le texte */
C=0;
for (I=0; TXT[I]; I++)
if (TXT[I]=='e') C++;
printf("Le texte contient %d lettres 'e'.\n",C);
/* c) Afficher la phrase l'envers */
for (I=L-1; I>=0; I--)
putchar(TXT[I]); /* ou printf("%c",TXT[I]); */
putchar('\n');
/* ou printf("\n"); */
/* d) Inverser l'ordre des caractres */
for (I=0,J=L-1 ; I<J ; I++,J--)
{
AIDE=TXT[I];
TXT[I]=TXT[J];
TXT[J]=AIDE;
}
puts(TXT); /* ou printf("%s\n",TXT); */
getch();
}
61/76
Exercice n8
#include <stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
/* Dclarations */
char TXT[201]; /* chane donne
*/
int I,J,N;
/* indices courants */
printf("Entrez une ligne de texte (max.200 caractres) :\n");
gets(TXT);
/* Eliminer les lettres 'e' et comprimer : */
/* Copier les caractres de I vers J et incrmenter J */
/* seulement pour les caractres diffrents de 'e'.
*/
N=strlen(TXT);
I=0; J=0;
while(I<N)
{
if (TXT[I] != 'e'){
TXT[J] = TXT[I];
J++;
}
I++;
}
/* Terminer la chane !! */
TXT[J]='\0';
puts(TXT);
getch();
Exercice n9
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
/* Dclarations */
char VERB[20]; /* chane contenant le verbe */
char AFFI[30]; /* chane pour l'affichage
*/
int L;
/* longueur de la chane
*/
printf("Verbe : ");
gets(VERB);
/* Contrler s'il s'agit d'un verbe en 'er' */
L=strlen(VERB);
if ((VERB[L-2]!='e') || (VERB[L-1]!='r'))
puts("\aCe n'est pas un verbe du premier groupe.!");
else
{
/* Couper la terminaison 'er'. */
VERB[L-2]='\0';
/* Conjuguer ... */
AFFI[0]='\0';
strcat(AFFI, "je ");
strcat(AFFI, VERB);
strcat(AFFI, "e");
puts(AFFI);
. . .
62/76
AFFI[0]='\0';
strcat(AFFI, "ils ");
strcat(AFFI, VERB);
strcat(AFFI, "ent");
puts(AFFI);
}
getch();
}
Exercice n10
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
/* Dclarations */
char CH1[200], CH2[200]; /* chanes entres */
int RES; /* rsultat de la fonction strcmp */
printf("Introduisez la premire chane de caractres : "); gets(CH1);
printf("Introduisez la deuxime chane de caractres : "); gets(CH2);
/* Comparaison et affichage du rsultat */
RES = strcmp(CH1,CH2);
if (RES<0)
printf("\"%s\" prcde \"%s\"\n",CH1 ,CH2);
else if (RES>0)
printf("\"%s\" prcde \"%s\"\n",CH2 ,CH1);
else
printf("\"%s\" est gal \"%s\"\n",CH1, CH2);
return 0;
}
Exercice n11
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main(){
/* Dclarations */
char mot[30];
int n,i;
printf("Entrer un mot:");
scanf("%s",mot);
n=strlen(mot)-1;
//1ere solution
i=0;
while((mot[i]==mot[n-i]) && (i<=(n/2))){
i++;
}
/*
//2me solution
i=-1; /*initialisation*/
do{
i++; /*incrementation*/
}while((mot[i]!=mot[n-i]) || (i==(n/2)));
*/
if(mot[i]==mot[n-i])
printf("Le mot %s est palindrome \n",mot);
else
printf("Le mot %s n'est pas palindrome \n",mot);
getch();
}
63/76

Semestre : 1
TP n5
Objectifs de ce TP c'est l'utilisation des fonctions pour rsoudre des problmes. Comment dclarer
une fonction et comment se fait l'appel de cette dernire?
Exercice n1
crire un programme se servant d'une fonction MOYENNE du type float pour afficher la
moyenne arithmtique de deux nombres rels entrs au clavier.
Exercice n2
crire une fonction MIN et une fonction MAX qui dterminent le minimum et le maximum de
deux nombres rels.
crire un programme se servant des fonctions MIN et MAX pour dterminer le minimum et le
maximum de quatre nombres rels entrs au clavier.
Exercice n3
crire la fonction AJOUTE_CH deux paramtres CH1 et CH2 qui copie la chane de
caractres CH2 la fin de la chane CH1 sans utiliser de variable d'aide.
crire le programme principale permettant de saisir deux chanes et de faire appel la fonction
AJOUT_CH.
Exercice n4
crire la fonction IsPalindrome qui permet de vrifier si le nom en paramtre est palindrome ou
non. La fonction retourne vrai si c'est le cas et faux sinon.
crire le programme principale permettant de saisir un nom et de faire appel la fonction
IsPalindrome.
64/76
Exercice n5
crire un programme qui permet de remplir un tableau dentiers de dimension N (tel que N50) et
dafficher les nombres impairs.
NB : Le programme doit comporter au minimum une fonction et deux procdures.
65/76
Correction du TP n5
Exercice n1
#include<stdio.h>
#include<conio.h>
float MOYENNE(float X, float Y)
{
return (X+Y)/2;
}
void main()
{
/* Variables locales */
float A,B;
/* Traitements */
printf("Introduire deux nombres : ");
scanf("%f %f", &A, &B);
printf("La moyenne arithmtique de %f et %f est %f\n",
A, B, MOYENNE(A,B));
getch();
}
Exercice n2
#include <stdio.h>
#include<conio.h>
double MIN(double X, double Y)
{
if (X<Y)
return X;
else
return Y;
}
double MAX(double X, double Y)
{
if (X>Y)
return X;
else
return Y;
}
void main()
{
/* Variables locales */
double A,B,C,D;
/* Traitements */
printf("Introduire 4 rels : ");
scanf("%lf %lf %lf %lf", &A, &B, &C, &D);
printf("Le minimum des 4 rels est %f \n",
MIN( MIN(A,B), MIN(C,D)) );
printf("Le maximum des 4 rels est %f \n",
MAX( MAX(A,B), MAX(C,D)) );
getch();
}
66/76
Exercice n3
#include<stdio.h>
#include<conio.h>
Ou aussi
#include<string.h>
void AJOUTE_CH(char *CH1, char *CH2)

{
while (*CH1) /* chercher la fin de CH1 */
CH1++;
while (*CH2) /* copier CH2 la fin de
CH1 */
{
*CH1 = *CH2;
CH1++;
CH2++;
}
*CH1='\0'; /* terminer la chane CH1 */
}
void AJOUTE_CH1(char *CH1, char *CH2)

{
int i,n1,n2;
n1=strlen(CH1);
n2=strlen(CH2);
for(i=0;i<n2;i++)
{
CH1[i+n1]=CH2[i];
}
CH1[n1+n2]='\0';
}
void main()
{
char Chaine1[30];
char Chaine2[30];
printf("Entrer chaine n1:");
gets(Chaine1);
printf("Entrer chaine n2:");
gets(Chaine2);
AJOUTE_CH(Chaine1,Chaine2);
printf("La nouvelle est chaine 1 est :%s",Chaine1);
}
Exercice n4
#include <stdio.h>
#include<conio.h>
#include<string.h>
int isPalindrome(char LeNom[])
{
int i,n;
n = strlen(LeNom)-1;
i=0;
while((LeNom[i]!= LeNom[n-i+1]) && (i<=n/2))
{
i++;
}
if(LeNom[i]!= LeNom[n-i+1])
return 0;
else
return 1;
}
void main()
{
/* Variable locale */
char nom[50];
/* Traitements */
printf("Introduire votre nom : ");
scanf("%s", nom);
if(isPalindrome(nom)==0)
printf("Le nom n'est pas palindrome");
else
printf("Le nom est palindrome");
getch();
}
67/76
Exercice n5
#include<stdio.h>
#include<conio.h>
int TailleTableau()
/* fonction qui retourne la taille du tableau */
{
int Taille;
do
{
printf("Taille du tableau (N<=50) =");
scanf("%d",&Taille);
}while(Taille<0 || Taille>50);
return Taille;
}
void Remplissage(int Taille,int *TAB) /* fonction remplissage du tableau */
{
int i;
for(i=0;i<Taille;i++)
{
printf("Elment n %d :",i+1);
scanf("%d",&TAB[i]);
}
}
void Affichage(int Taille, int TAB[])
{
int i;
for(i=0;i<Taille;i++)
{
if(TAB[i] % 2 !=0)
printf("% d ",TAB[i]);
}
}
void main()
{
int N;
int T[50];
N=TailleTableau();
Remplissage(N,&T);
Affichage(N,T);
getch();
}
68/76
Universit de Jendouba
Facult des Sciences Juridiques, Economiques et de Gestion de Jendouba
Classe
1re anne Licence Fondamentale en Informatique Applique la Gestion
Matire
Atelier de programmation I
Enseignant
Riadh BOUSLIMI
Session
Principale (Janvier 2010)
Dure
2 heures
Documents
Non autoriss
EXAMEN
Exercice n1 (4 points)
crire un programme qui permet de saisir deux chaines CH1 et CH2, de les concatner ensembles et dafficher la
nouvelle chaine CH3 obtenue.
Exemple:
CH1=TRAVAILLER PLUS
CH2=GAGNER PLUS
CH3=TRAVAILLER PLUSGAGNER PLUS
crire un programme qui permet de saisir deux chaines dates Date1 et Date2 de la forme JJ/MM/AA.
On suppose que ces dernires sont deux dates valides et que Date1Date2.
Dterminer et afficher le nombre de jours de diffrence entre ces deux dates.
Exemple:
Date1=19/12/2008
Date2=05/06/2009
Le nombre de jours de diffrence est : 168 jours
NB : Les deux dates sont de types char de 10 caractres; pour extraire le jour, le mois et lanne vous devez employer la
fonction prdfinie atoi de la bibliothque (stdlib.h) qui permet de convertir une chaine en entier.
int atoi(char *chane) convertit la chane en entier

exemple:
gets(texte);
n = atoi(texte) ;
printf("%d",n); /* affiche 12 si texte vaut "12" */
crire un programme qui lit deux chaines CH1 et CH2, de compter et dafficher le nombre
doccurrences de CH2 dans CH1.
Exemple:
CH1=tre bon en algorithmique est quivalent tre bon en atelier de programmation.
CH2=tre bon
Le nombre doccurrences est : 2
Bonne Chance
69/76
Correction dexamen session principale

Module : Atelier de programmation I 1LFIAG
Exercice n1 (4pts)
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main(){
char ch1[30];
char ch2[30];
char ch3[60];
int i,j,LongeurCh1,LongeurCh2;
printf("Chaine 1=");gets(ch1);
printf("Chaine 2=");gets(ch2);
LongeurCh1=strlen(ch1);
//copie de la premire chaine
for(i=0;i<LongeurCh1;i++)
ch3[i]=ch1[i];
//copie de la deuxime chaine
for(j=0;j<LongeurCh2;j++)
ch3[j+i]=ch2[j];
//fin de la chaine
ch3[j+i]='\0';
printf("\n La nouvelle chaine : %s \n",ch3);
getch();
}
Exercice n2 (4pts)
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int GetNombreJoursDuMois(int Mois,int Annee){
int nbJours;
switch (Mois){
case 1 : nbJours=31;break;
case 2 : if ((Annee % 4) == 0)
nbJours=29;
else
nbJours=28;
break;
}
return nbJours;
}
70/76
void main(){
char Date1[10];
char Date2[10];
char C1_JJ[3],C1_MM[3],C1_AAAA[5];
char C2_JJ[3],C2_MM[3],C2_AAAA[5];
int JJ1,MM1,AAAA1;
int JJ2,MM2,AAAA2;
int i,j,nbAnnee,NombreDeJours;
printf("Date1=");gets(Date1);
printf("Date2=");gets(Date2);
//Extraction du Jour, du mois et de l'anne de Date1
C1_JJ[0]=Date1[0];C1_JJ[1]=Date1[1];C1_JJ[2]='\0';
C1_MM[0]=Date1[3];C1_MM[1]=Date1[4];C1_MM[2]='\0';
C1_AAAA[0]=Date1[6];C1_AAAA[1]=Date1[7];
C1_AAAA[2]=Date1[8];C1_AAAA[3]=Date1[9];C1_AAAA[4]='\0';
//Extraction du Jour, du mois et de l'anne de Date2
C2_JJ[0]=Date2[0];C2_JJ[1]=Date2[1];C2_JJ[2]='\0';
C2_MM[0]=Date2[3];C2_MM[1]=Date2[4];C2_MM[2]='\0';
C2_AAAA[0]=Date2[6];C2_AAAA[1]=Date2[7];
C2_AAAA[2]=Date2[8];C2_AAAA[3]=Date2[9];C2_AAAA[4]='\0';
//Conversion en entier
JJ1=atoi(C1_JJ);MM1=atoi(C1_MM);AAAA1=atoi(C1_AAAA);
JJ2=atoi(C2_JJ);MM2=atoi(C2_MM);AAAA2=atoi(C2_AAAA);
nbAnnee=AAAA2-AAAA1;
NombreDeJours=0;
if (AAAA2==AAAA1)
{
if (MM1==MM2)
NombreDeJours=JJ2-JJ1;
else
{
for(i=MM1+1;i<=MM2-1;i++)
NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i,AAAA1);
NombreDeJours=NombreDeJours+JJ2+GetNombreJoursDuMois(MM1,AAAA1)-JJ1;
}
}
else
{
//nb jours du mois suivant jusqu' la fin de l'anne de Date1
for(i=MM1+1;i<=12;i++)
//nb jours du mois de diffrences entre AAAA+1 et AAAA2-1
if (nbAnnee!=1)
{
for(j=AAAA1+1;j<=AAAA2-1;j++)
{
for(i=1;i<=12;i++)
NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i,j);
}
}
//nb jours du mois de janvier jusqu' le mois prcdent de Date2
for(i=MM2-1;i>=1;i--)
NombreDeJours=NombreDeJours+JJ2+GetNombreJoursDuMois(MM1,AAAA1)-JJ1;
}
printf("\n Le nombre de jours de diffrences est %d \n",NombreDeJours);

getch();
71/76
Exercice n3 (9pts)
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main(){
char ch1[100];
char ch2[100];
int i,j;
int LongeurCh1,LongeurCh2,nbOcc;
printf("Entrer ch1:");gets(ch1);
printf("Entrer ch2:");gets(ch2);
nbOcc=0;
i=0;
while(i<LongeurCh1){
j=0;
while((ch1[i]!=ch2[j]) && (i<LongeurCh1))
i++;
while((ch1[i]==ch2[j]) && (i<LongeurCh1) && (j<LongeurCh2)){
i++;
j++;
}
if (j==LongeurCh2)
nbOcc++;
}
printf("\n Le nombre d'occurrences de %s dans %s est :
%d\n",ch2,ch1,nbOcc);
getch();
72/76
Universit de Jendouba
Facult des Sciences Juridiques, Economiques et de Gestion de Jendouba
Classe
1re anne Licence Fondamentale en Informatique Applique la Gestion
Matire
Atelier de programmation I
Enseignant
Riadh BOUSLIMI
Session
Contrle (Juin 2010)
Dure
2 heures
Documents
Non autoriss
EXAMEN
crire une fonction NbCarMajus qui permet de compter le nombre des lettres en majuscules.
Ecrire le programme principal qui permet de saisir une chaine CH, et dafficher le rsultat lcran.
Exemple:
CH= "Faculte des Sciences Juridiques Economiques et de Gestion de Jendouba"
N=5
crire un programme qui permet de remplir un tableau contenant des notes (avec 0 note20),
dont la dimension du tableau est 5n30. On suppose que les notes ont le mme coefficient.
De calculer la moyenne et dafficher le rsultat lcran.
Exemple:
14
12.5
6.25
13.75
11.5
La moyenne est : 11.6

crire un programme qui permet de saisir deux chaines CH1 et CH2, dextraire de ces dernires que
les chiffres, deffectuer la somme des deux nombres et enfin afficher le rsultat lcran.
Exemple:
CH1= "N5jrt23fe6K"
nb1 = 5236
CH2= "p3Y2"
nb2 = 32
La somme des deux nombres est : 5268

NB : vous devez employer la fonction prdfinie atoi de la bibliothque (stdlib.h) qui permet de
convertir une chaine en entier.
int atoi(char *chane)
convertit la chane en entier
exemple:
ch="12" ;
nb = atoi(ch) ; /* nb=12 */
Bonne Chance
73/76
Correction dexamen session contrle

Module : Atelier de programmation I 1LFIAG
Exercice n1 (4pts)
#include <stdio.h>
#include <conio.h>
#include <string.h>
int NbCarMajus(char ch[])
{
int i,n,occ;
n=strlen(ch);
occ=0; /* initialisation du compteur des majuscules */
for(i=0;i<n;i++)
{
if((ch[i]>='A') && (ch[i]<='Z'))
occ++; /* incrmentation du compteur */
}
return occ;
}
void main()
{
char ch[50];
printf("Taper une chaine:");gets(ch);
printf("Le nombre des lettres majuscules : %d\n",NbCarMajus(ch));
printf("Pour sortir frapper une touche ");
getch();
}
Exercice n2 (6pts)
#include <stdio.h>
#include <conio.h>
int TailleTab()
{
int taille;
do{
printf("Entrer la taille du tableau:");
scanf("%d",&taille);
}while((taille<5) || (taille>30));
return taille;
}
void Remplissage(int *TAB,int n)
{
int i;
float note;
for(i=0;i<n;i++)
{
do{
printf("Entre la note n
%d:",i+1);
scanf("%d",&note);
}while((note<0) || (note>20));
TAB[i]=note;
}
}
float calculer(int TAB[],int n)
{
int i;
float som;
for(i=0;i<n;i++)
som+=TAB[i];
return som/n;
}
74/76
void main()
{
int n;
float moy;
int T[100];
n=TailleTab(); /* Affectation de la taille du tableau */
Remplissage(&T,n); /* remplissage du tableau */
moy=calculer(T,n); /* calcul et affectation de la moyenne */
printf("La moyenne est : %f\n",moy); /* Affichage de la moyenne */
getch();
}
Exercice n3 (10pts)
#include
#include
#include
#include
<stdio.h>
<conio.h>
<string.h>
<stdlib.h>
int extraire(char ch[])

{
int i,j;
char nbr[];
int n = strlen(ch); /* taille de la chaine */
j=-1;
for(int i=0;i<n;i++) /* parcours de la chaine */
{
if(ch[i]>='0' && (ch[i]<='9'))
{
j++;
nbr[j]=ch[i]; /* ajout du nombre dans la nouvelle chaine nbr */
}
}
return atoi(nbr); /* convertion du nombre en numrique */
}
int somme(int nb1,int nb2)
{
return nb1+nb2;
}
void main()
{
char ch1[100];
char ch2[100];
int som;
printf("Entrer chaine ch1=");gets(ch1);
printf("Entrer chaine ch2=");gets(ch2);
som=somme(extraire(ch1),extraire(ch2)); /* appel des deux fonctions */
printf("La somme est : %d\n",som); /* Affichage de la somme */
getch();
}
75/76
ibliographie
Achille Braquelaire
Mthodologie de la programmation en C
2me dition, septembre 2004 Editions Dunod
Brian W. Kernighan et Dennis M. Ritchie
Le langage C - Initiation la programmation
Norme ANSI, 2me dition, 2004
Claude Delannoy
Programmer en langage C - notions de programmation acquises par la pratique
2me dition, Avril 2002 Editions Dunod
Peter Prinz et Ulla Kirch-Prinz
C prcis et concis - Syntaxe et fondamentaux du langage C
4 me dition, Mars 2005 Editions Dunod
Yves Mettier
C en action- Solutions et exemples pour les programmeurs en C
1 re dition, juin 2005 Editions O'Reilly
76/76

API

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

API

Transféré par

Droits d'auteur :

Formats disponibles

REPUBLIQUE TUNISIENNE

MINISTERE DE LENSEIGNEMENT SUPERIEUR ET DE

FASCICULE DE Cours et TPs

Anne Universitaire : 2009-2010

Table des matires

Manipuler les types standard.

math.h : bibliothque de fonctions mathmatiques

On ne saurait dvelopper un programme en C sans se munir de la documentation concernant

Dans ce programme, on introduit 3 nouveaux concepts :

3. LES DIFFERENTS TYPES DE VARIABLES

entier standard sign

4 octets: - 231 n 231-1

entier court sign

2 octets: - 215 n 215-1

5. SORTIES DE NOMBRES OU DE TEXTE A L'ECRAN

/* pas de retour la ligne du curseur aprs l'affichage, */

/* c est le caractere alphanumerique A */

Rsultat aprs compilation et excution:

Affichage multiple de structure:

Formats de sortie pour les entiers:

affichage en dcimal (entiers de type int),

/* p est gale n dcal de 3 bits gauche */

Manipuler les fonctions d'entre de base

printf("POUR CONTINUER FRAPPER UNE TOUCHE ");

- avec retour de variable au programme:

/* saisie d'un caractre */

Savoir les structures conditionnelles ainsi que ces diffrentes formes.

1. L'INSTRUCTION SI ... ALORS ... SINON ...

si (expression conditionnelle vraie)

Le bloc "sinon" est optionnel:

" si a gal b "

test de non galit:

" si a diffrent de b "

tests de relation d'ordre:

if ((expression1) && (expression2))

test de NON LOGIQUE

Toutes les combinaisons sont possibles entre ces tests.

Le langage C admet des critures contractes dans les expressions de test:

3. L'INSTRUCTION AU CAS OU ... FAIRE ...

tant que (expression vraie)

Le test se fait d'abord, le bloc d'instructions n'est pas forcment excut.

5. L'INSTRUCTION POUR ...

for(i = 0 ; i<10 ; i++)

correspond l'organigramme suivant:

est une boucle infinie (rptition infinie du bloc d'instructions).

Le test se faisant aprs, le bloc est excut au moins une fois.

Comprendre l'utilisation du type tableau.

1. LES TABLEAUX DE NOMBRES (INT ou FLOAT)

Dclaration: type nom[dim];

Les tableaux plusieurs dimensions:

2. INITIALISATION DES TABLEAUX

3. LES CHAINES DE CARACTERES

Le compilateur rserve (dim-1) places en mmoire pour la chane de caractres: En effet, il

fournit la longueur de la chane sans compter le '\0' final

copie <t> vers <s>

La concatnation de chanes de caractres en C ne se fait pas par le symbole '+' comme en

Comprendre l'intrt des fonctions

3. FONCTIONS SANS PASSAGE D'ARGUMENTS ET NE RENVOYANT RIEN AU

/* variable globale, connue de tout le programme */

void fonction2(int a, float b, char c)

6. RESUME SUR VARIABLES ET FONCTIONS

7. LE PASSAGE DE PARAMETRES ENTRE FONCTIONS OU ENTRE FONCTIONS ET

Exemple: Fonction permettant d'changer la valeur de 2 variables:

Anne Universitaire : 2009/2010

void itoa(int n,char chane,int base) convertit un entier en chane:

void AJOUTE_CH(char CH1, char CH2)

void AJOUTE_CH1(char CH1, char CH2)