Atelier de Programmation I

REPUBLIQUE TUNISIENNE
MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE

LA RECHERCHE SCIENTIFIQUES ET TECHNOLOGIQUES
UNIVERSITE DE JENDOUBA
FACULTE DES SCIENCES JURIDIQUES, ECONOMIQUES ET DE GESTION DE JENDOUBA
Support de cours
Atelier de Programmation I
Adressé aux étudiants de la 1ère année Licence Fondamentale en

Informatique Appliquée à la Gestion
Élaboré par
Riadh BOUSLIMI
Technologue en Informatique
Année Universitaire : 2009-2010

Table des matières
Chapitre 1 : ELEMENTS DE LANGAGE C .................................................................................................................... 3
1. INTRODUCTION........................................................................................................................................ 3
2. ETAPES PERMETTANT L'EDITION, LA MISE AU POINT, L'EXECUTION D'UN
PROGRAMME ........................................................................................................................................................ 3
3. LES DIFFERENTS TYPES DE VARIABLES.......................................................................................... 4
4. LES INITIALISATIONS ............................................................................................................................ 6
5. SORTIES DE NOMBRES OU DE TEXTE A L'ECRAN ........................................................................ 7
6. LES OPERATEURS .................................................................................................................................... 9
7. LES CONVERSIONS DE TYPES............................................................................................................ 10
Chapitre 2 : SAISIE DE NOMBRES ET DE CARACTERES AU CLAVIER ............................................................ 12
1. LA FONCTION GETCH .......................................................................................................................... 12
2. LA FONCTION SCANF ........................................................................................................................... 12
3. LA FONCTION GETCHAR .................................................................................................................... 13
Chapitre 3 : LES STRUCTURES CONDITIONNELLES ET LES BOUCLES ......................................................... 14
1. L'INSTRUCTION SI ... ALORS ... SINON ... ......................................................................................... 14
2. LES OPERATEURS LOGIQUES ............................................................................................................ 15
3. L'INSTRUCTION AU CAS OU ... FAIRE ... .......................................................................................... 16
4. LA BOUCLE TANT QUE ... FAIRE ... ................................................................................................... 17
5. L'INSTRUCTION POUR ... ..................................................................................................................... 18
6. L'INSTRUCTION REPETER ... TANT QUE ........................................................................................ 19
Chapitre 4 : LES TABLEAUX ET LES CHAINES DE CARACTERES ..................................................................... 21
1. LES TABLEAUX DE NOMBRES (INT ou FLOAT) ............................................................................. 21
2. INITIALISATION DES TABLEAUX ..................................................................................................... 22
3. LES CHAINES DE CARACTERES ........................................................................................................ 22
4. FONCTIONS SUR LES CHAINES DE CARACTERES ....................................................................... 23
Chapitre 5 : LES FONCTIONS........................................................................................................................................ 24
1. INTRODUCTION...................................................................................................................................... 24
2. DECLARATION........................................................................................................................................ 24
3. FONCTIONS SANS PASSAGE D'ARGUMENTS ET NE RENVOYANT RIEN AU
PROGRAMME. ..................................................................................................................................................... 25
4. FONCTION RENVOYANT UNE VALEUR AU PROGRAMME ET SANS PASSAGE
D'ARGUMENTS ................................................................................................................................................... 28
5. FONCTIONS AVEC PASSAGE D'ARGUMENTS................................................................................ 28
6. RESUME SUR VARIABLES ET FONCTIONS..................................................................................... 29
7. LE PASSAGE DE PARAMETRES ENTRE FONCTIONS OU ENTRE FONCTIONS ET
PROGRAMME PRINCIPAL ............................................................................................................................... 29
TP n°1 ................................................................................................................................................................................. 31
Correction du TP n°1 ........................................................................................................................................................ 32
TP n°2 ................................................................................................................................................................................. 34
TP n°3 ................................................................................................................................................................................. 42
TP n°4 ................................................................................................................................................................................. 50
CORRECTION DU TP N°4.............................................................................................................................................. 54
TP n°5 ................................................................................................................................................................................. 61
Examen session principale (Janvier 2009) ....................................................................................................................... 66
Correction d’examen session principale .......................................................................................................................... 67
Examen session de contrôle (Juin 2009) ........................................................................................................................... 70
Correction d’examen session contrôle.............................................................................................................................. 71
Bibliographie ...................................................................................................................................................................... 73
2/73
Chapitre 1
ELEMENTS DE LANGAGE C
Objectifs spécifiques:
Manipuler les types standard.
Déclarer des variables.
Savoir les opérateurs de base du langage c.
Savoir utiliser les Bibliothèques.
Savoir afficher et utiliser les formats de sorties des variables.
Savoir écrire un programme C, le compiler et l'exécuter.
Savoir convertir un type de données vers un autre.
1. INTRODUCTION
Le langage C est un langage évolué et structuré, assez proche du langage machine destiné à des
applications de contrôle de processus (gestion d'entrées/sorties, applications temps réel ...).
Le langage C possède assez peu d'instructions, il fait par contre appel à des bibliothèques, fournies en
plus ou moins grand nombre avec le compilateur.
exemples: math.h : bibliothèque de fonctions mathématiques

stdio.h : bibliothèque d'entrées/sorties standard
On ne saurait développer un programme en C sans se munir de la documentation concernant

ces bibliothèques.
Les compilateurs Borland C++ ou TurboC++ permettent de compiler et exécuter des

programmes c et ils offrent la documentation nécessaire.
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 création des codes machine destinés au
microprocesseur utilisé. Le compilateur indique les erreurs de syntaxe mais ignore les fonctions-
bibliothèque appelées par le programme.
Le compilateur génère un fichier binaire, non listable, appelé fichier objet: EXI_1.OBJ (commande
« compile »).
3- Editions de liens: Le code machine des fonctions-bibliothèque est chargé, création d'un fichier
binaire, non listable, appelé fichier executable: EXI_1.EXE (commande « build all »).
4- Exécution du programme (commande « flèche jaune »).
Les compilateurs permettent en général de construire des programmes composés de plusieurs fichiers
sources, d'ajouter à un programme des unités déjà compilées ...
3/73
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 */
}
Résultat après compilation et exécution:
Le langage C distingue les minuscules, des majuscules. Les mots réservés du langage C doivent être
écrits en minuscules.
On a introduit dans ce programme la notion d’interface homme/machine (IHM).

- L’utilisateur visualise une information sur l’écran,
- L’utilisateur, par une action sur le clavier, fournit une information au programme.
Exemple 2
#include <conio.h>
void main()
{
int a, b, somme ; /* déclaration de 3 variables */
a = 10 ; /* affectation* /
b = 50 ; /* affectation */
somme = (a + b)*2 ; /* affectation et opérateurs */
printf("Voici le resultat : %d\n ", somme) ;
}
Dans ce programme, on introduit 3 nouveaux concepts :

- La notion de déclaration de variables : les variables sont les données que manipulera le
programme lors de son exécution. Ces variables sont rangées dans la mémoire vive de
l’ordinateur. Elles doivent être déclarées au début du programme.
- La notion d’affectation, symbolisée par le signe =.
- La notion d’opération.
3. LES DIFFERENTS TYPES DE VARIABLES
4/73
a) Les entiers
Le langage C distingue plusieurs types d'entiers:

___________________________________________________________
TYPE DESCRIPTION TAILLE MEMOIRE

___________________________________________________________
int entier standard signé 4 octets: - 231 ≤ n ≤231-1

unsigned int entier positif 4 octets: 0 ≤ n ≤ 232
short entier court signé 2 octets: - 215 ≤ n ≤ 215-1

unsigned short entier court non signé 2 octets: 0 ≤≤n ≤ 216
char caractère signé 1 octet : - 27 ≤≤n ≤ 27-1

unsigned char caractère non signé 1 octet : 0 ≤n ≤ 28
_____________________________________________________________
Numération: En décimal les nombres s'écrivent tels que, précédés de 0x en hexadécimal.

exemple: 127 en décimal s'écrit 0x7f en hexadécimal.
Remarque: En langage C, le type char est un cas particulier du type entier:
un caractère est un entier de 8 bits
Exemples:
Les caractères alphanumériques s'écrivent entre ‘ ‘
Le caractère 'b' a pour valeur 98 (son code ASCII).

Le caractère 22 a pour valeur 22.
Le caractère 127 a pour valeur 127.
Le caractère 257 a pour valeur 1 (ce nombre s'écrit sur 9 bits, le bit de poids fort est perdu).
Quelques constantes caractères:

________________________________________________________________
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 "
_______________________________________________________________
5/73
Exemple 3

#include <conio.h>
void main()
{
int a, b, calcul ; /* déclaration de 3 variables */
char u, v;
a = 10 ; /* affectation* /
b = 50 ; /* affectation */
u = 65 ;
v = ‘A’ ;
calcul = (a + b)*2 ; /* affectation et opérateurs */
printf(« Voici le resultat : %d\n », calcul) ;
printf(« 1er affichage de u : %d\n »,u) ;
printf(« 2ème affichage de v : %c\n »,u) ;
printf(« 1er affichage de u: %d\n »,v) ;
printf(« 2éme affichage de v: %c\n »,v) ;
puts("Pour continuer frapper une touche...");
}
b) Les réels
Un réel est composé - d'un signe - d'une mantisse - d'un exposant

Un nombre de bits est réservé en mémoire pour chaque élément.
Le langage C distingue 2 types de réels:

_________________________________________________________
TYPE DESCRIPTION TAILLE MEMOIRE

_________________________________________________________
float réel standard 4 octets
double réel double précision 8 octets
__________________________________________________________
4. LES INITIALISATIONS
Le langage C permet l'initialisation des variables dans la zône des déclarations:
char c; est équivalent à char c = 'A';

c = 'A';
int i; est équivalent à int i = 50;
i = 50;
Cette règle s'applique à tous les nombres, char, int, float ...
6/73
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 bibliothèque stdio.h.
Exemple: affichage d'un texte:
printf("BONJOUR"); /* pas de retour à la ligne du curseur après l'affichage, */

printf("BONJOUR\n"); /* 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; /* c est le caractere alphanumerique A */
printf("%d\n",c); /* 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 caractère */
/* et retour à la ligne */
}
7/73
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 affichage en décimal (entiers de type int),

%x affichage en hexadécimal (entiers de type int),
%u affichage en décimal (entiers de type unsigned int),
Exercice d'application n°1

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 décimal, et en soignant l’interface 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...");
}
8/73
Exercice d'application n°2
Soit a et b sont des réels, a = -21,43 b = 4,782, calculer et afficher a+b, a-b, a*b, a/b, en
soignant l’interface homme/machine.
NB : Pour le format de sortie pour les réels 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 caractère: La fonction putchar permet d'afficher un caractère:

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 formatées, sont
d'exécution plus rapide, et nécessitent moins de place en mémoire lors de leur chargement.
6. LES OPERATEURS
Opérateurs arithmétiques sur les réels: + - * / avec la hiérarchie habituelle.
Opérateurs arithmétiques sur les entiers: + - * / (quotient de la division) % (reste de la division)

avec la hiérarchie habituelle.
Exemple particulier: char c,d;

c = 'G';
d = c+'a'-'A';
Les caractères sont des entiers sur 8 bits, on peut donc effectuer des opérations. Sur cet exemple, on
transforme la lettre majuscule G en la lettre minuscule g.
Opérateurs logiques sur les entiers:

& ET | OU ^ OU EXCLUSIF ~ COMPLEMENT A UN « DECALAGE A GAUCHE
» DECALAGE A DROITE.
Exemples: p = n « 3; /* p est égale à n décalé de 3 bits à gauche */

p = n » 3; /* p est égale à n décalé de 3 bits à droite */
9/73
INCREMENTATION - DECREMENTATION
Le langage C autorise des écritures simplifiées pour l'incrémentation et la décrémentation de

variables:
i = i+1; est équivalent à i++;
i = i-1; est équivalent à i--;
OPERATEURS COMBINES
Le langage C autorise des écritures simplifiées lorsqu'une même variable est utilisée de chaque côté
du signe = d'une affectation. Ces écritures sont à éviter lorsque l'on débute 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 méthodes pour définir des constantes.

1ere méthode: déclaration 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 réserve de la place en mémoire (ici 4 octets), pour la variable pi, mais
dont on ne peut changer la valeur.
2ème méthode: définition 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 réserve pas de place en mémoire. Les constantes déclarées 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 opérations de conversion de type: On utilise pour cela l'opérateur
de "cast"().
10/73
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();
}
11/73
Chapitre 2
SAISIE DE NOMBRES ET DE CARACTERES AU CLAVIER
Manipuler les fonctions d'entrée de base
Savoir la différence entre les fonctions d'entrée et leurs lieux d'utilisation
1. LA FONCTION GETCH
La fonction getch, appartenant à la bibliothèque conio.h permet la saisie clavier d'un caractère
alphanumérique. La saisie s'arrête dès que le caractère a été frappé.
On peut utiliser getch de deux façons:
- 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 parenthèses vides de getch() signifient qu'aucun paramètre n'est passé à cette fonction par
le programme.
2. LA FONCTION SCANF
La fonction scanf, appartenant à la bibliothèque stdio.h, permet la saisie clavier de n'importe quel
type de variable.
Les variables à saisir sont formatées, le nom de la variable est précédé du symbole & désignant
l'adresse de la variable.
Exemples: char alpha;

int i;
float r;
scanf("%c",&alpha); /* saisie d'un caractère */
scanf("%d",&i); /* saisie d'un nombre entier en décimal */
scanf("%x",&i); /* saisie d'un nombre entier en hexadécimal*/
scanf("%f",&r); /* saisie d'un nombre réel */
12/73
Remarque: Si l'utilisateur ne respecte pas le format indiqué dans scanf, la saisie est ignorée. Aucune
erreur n'est générée.
Exemple: char alpha;

scanf("%d",&alpha);
Si l'utilisateur saisie 97 tout va bien, alpha devient le caractère dont le code ASCII vaut 97.
Si l'utilisateur saisie a, sa saisie est ignorée.
3. LA FONCTION GETCHAR
La fonction getchar pemet la saisie d'un caractère (char). Elle appartient à la bibliothèque stdio.h.
Les 2 écritures suivantes sont équivalentes:
char c; char c;
printf("ENTRER UN CARACTERE: "); printf("ENTRER UN CARACTERE: ");
scanf("%c",&c); c = getchar();
La fonction getchar est moins gourmande en place mémoire que scanf. Il vaut mieux l'utiliser quand
cela est possible; getchar utilise le flux d'entrée exactement comme scanf.
13/73
Chapitre 3
LES STRUCTURES CONDITIONNELLES ET LES BOUCLES
Savoir les structures conditionnelles ainsi que ces différentes formes.
Savoir combiner deux ou plusieurs conditions.
Choisir la forme adéquate des structures de contrôle conditionnelles.
Savoir les structures itératives ainsi que ces différentes formes.
Choisir la forme adéquate des structures itératives.
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 condition non
vraie
bloc 1 d' bloc 2 d'

instructions instructions
suite du programme
Syntaxe en C: if (expression)
{
............; /* bloc 1 d'instructions */
............;
............;
}
else
{
............; /* bloc 2 d'instructions */
............;
............;
}
14/73
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 nécessaires 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 différent de b "
tests de relation d'ordre: if (a<b) if (a<=b) 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 "
15/73
Toutes les combinaisons sont possibles entre ces tests.
Le langage C admet des écritures contractées dans les expressions de test:
char reponse; est équivalent à char reponse;

printf("Voulez-vous jouer ?"); printf("Voulez-vous jouer ?");
reponse = getchar();
if(reponse == 'o') if((reponse = getchar()) =='o')
printf("BONJOUR\n"); printf("BONJOUR\n");
else printf("TANT-PIS"\n); 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 caractères
(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 précédentes: executer ce bloc
........; d'instructions, pas de "break" ici.
le bloc "default" n'est pas obligatoire.
L’instruction switch correspond à une cascade d’instructions if ...else
16/73
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 ...
Il s'agit de l'instruction: tant que (expression vraie)

faire{BLOC D'INSTRUCTIONS}
Organigramme:
oui non
condition
vraie
bloc d'
instructions
Syntaxe en C: while (expression)

{
............;
............;
}
17/73
Le test se fait d'abord, le bloc d'instructions n'est pas forcément exécuté.
Remarque:
- les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.
- On peut rencontrer la construction suivante: while (expression); terminée par un ; et
sans la présence du bloc d'instructions. Cette construction signifie: "tant que
l'expression est vraie attendre".
5. L'INSTRUCTION POUR ...
Il s'agit de l'instruction:
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 nécessaires lorsque le bloc ne comporte qu'une seule instruction.
Les 3 instructions du for ne portent pas forcément sur la même variable.
Une instruction peut être omise, mais pas les ;
18/73
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 (répétition infinie du bloc d'instructions).

Utilisation de variables différentes:
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 ...
Il s'agit de l'instruction: répéter{BLOC D'INSTRUCTIONS}

tant que (expression vraie)
19/73
Organigramme:
bloc d'
instructions
non
condition
oui vraie
suite du programme
Syntaxe en C: do
{
............;
............;
}
while (expression);
Le test se faisant après, le bloc est exécuté au moins une fois.
Remarque: les {} ne sont pas nécessaires lorsque le bloc ne comporte qu'une seule instruction.
20/73
Chapitre 4
LES TABLEAUX ET LES CHAINES DE CARACTERES
Comprendre l'utilisation du type tableau.
Savoir déclarer un tableau.
Manipuler des tableaux à une ou deux dimensions.
Manipuler des chaînes de caractères.
Manipuler les fonctions sur les chaines de caractères.
1. LES TABLEAUX DE NOMBRES (INT ou FLOAT)
Les tableaux correspondent aux matrices en mathématiques. Un tableau est caractérisé par sa
taille et par ses éléments.
Les tableaux à une dimension:
Déclaration: type nom[dim]; Exemples: int compteur[10];

float nombre[20];
Utilisation: Un élément du tableau est repéré par son indice. En langage C les tableaux
commencent à l'indice 0. L'indice maximum est donc dim-1.
Appel: nom[indice]
Exemples: compteur[2] = 5;
nombre[i] = 6.789;
printf("%d",compteur[i]);
scanf("%f",&nombre[i]);
Les tableaux à plusieurs dimensions:
Tableaux à deux dimensions:
Déclaration: type nom[dim1][dim2]; Exemples: int compteur[4][5];

float nombre[2][10];
Utilisation: Un élément du tableau est repéré 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]);
21/73
2. INITIALISATION DES TABLEAUX
On peut initialiser les tableaux au moment de leur déclaration:
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 chaînes de caractères sont des tableaux de caractères. Leur manipulation est donc
analogue à celle d'un tableau à une dimension:
Déclaration: char nom[dim];
Exemple: char texte[10];
Le compilateur réserve (dim-1) places en mémoire pour la chaîne de caractères: En effet, il

ajoute toujours le caractère NUL ('\0') à la fin de la chaîne en mémoire.
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 formatée:

puts(texte); est équivalent à printf("%s\n",texte);
Saisie: On peut utiliser la fonction scanf et le format %s. Une chaîne étant un pointeur, on
n'écrit pas le symbole &. On utilisera de préférence la fonction gets non formatée.
char texte[10];
printf("ENTRER UN TEXTE: ");
scanf("%s",texte); est équivalent à gets(texte);
22/73
Remarque: scanf ne permet pas la saisie d'une chaîne comportant des espaces: les caractères saisis à
partir de l'espace ne sont pas pris en compte (l'espace est un délimiteur au même titre que LF) mais
rangés dans le tampon d'entrée. Pour saisir une chaîne de type "il fait beau", il faut utiliser gets.
A l'issue de la saisie d'une chaîne de caractères, le compilateur ajoute '\0' en mémoire après le dernier
caractère.
4. FONCTIONS SUR LES CHAINES DE CARACTERES

La bibliothèque <string> fournit une multitude de fonctions pratiques pour le traitement de chaînes
de caractères. Voici quelques fonctions les plus fréquemment utilisées:
Fonctions pour le traitement de chaînes de caractères
strlen(<s>) fournit la longueur de la chaîne sans compter le '\0' final
strcpy(<s>, <t>) copie <t> vers <s>
strcat(<s>, <t>) ajoute <t> à la fin de <s>
strcmp(<s>, <t>) compare <s> et <t> lexicographiquement et fournit un résultat:
négatif si <s> précède <t>
zéro si <s> est égal à <t>
positif si <s> suit <t>
strncpy(<s>, <t>, <n>) copie au plus <n> caractères de <t> vers <s>
strncat(<s>, <t>, <n>) ajoute au plus <n> caractères de <t> à la fin de <s>
Remarques
- Comme le nom d'une chaîne de caractères représente une adresse fixe en mémoire, on ne peut
pas 'affecter' une autre chaîne au nom d'un tableau:
Il faut bien copier la chaîne caractère par caractère ou utiliser la fonction strcpy
respectivement strncpy: strcpy(A, "Hello");
- La concaténation de chaînes de caractères en C ne se fait pas par le symbole '+' comme en

langage algorithmique ou en Pascal. Il faut ou bien copier la deuxième chaîne caractère par
caractère ou bien utiliser la fonction strcat ou strncat.
- La fonction strcmp est dépendante du code de caractères et peut fournir différents résultats
sur différentes machines.
23/73
Chapitre 5
LES FONCTIONS
Comprendre l'intérêt des fonctions
Savoir déclarer, programmer et utiliser les fonctions.
1. INTRODUCTION
En langage C les sous-programmes s'appellent des fonctions.
L'imbrication de fonctions n'est pas autorisée en C: une fonction ne peut pas être déclarée à l'intérieur
d'une autre fonction. Par contre, une fonction peut appeler une autre fonction. Cette dernière doit être
déclarée avant celle qui l'appelle.
Une fonction possède un et un seul point d'entrée, 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 déclare une fonction ainsi :

type nom( type1 arg1 , type2 arg2, ... , typen argn)
{
déclaration variables locales ;
instructions ;
return expression ;
}
type est le type de la valeur renvoyée par la fonction. type1 est le type du 1er argument arg1 ....
Les variables locales sont des variables qui ne sont connues qu’à l’intérieur de la fonction.
expression est évaluée lors de l’instruction return (expression) ;, c’est la valeur que renvoie
la fonction quand elle est appelée depuis main().
Exemple de fonction :
float affine( float x ) { /* la fonction ’affine’ prend 1 argument réel */

/* et renvoie un argument réel */
int a,b ;
a=3 ;
b=5 ;
return a*x+b ; /* valeur renvoyée par la fonction */
}
24/73
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 dernière ne renvoie rien en retour.
Exemple 2
#include <stdio.h>
#include <conio.h>
void bonjour() /* declaration de la fonction */

{
printf("bonjour\n");
}
void coucou() /* declaration de la fonction */

{
bonjour(); /* appel d'une fonction dans une fonction */
printf("coucou\n");
}

{
coucou(); /* appel de la fonction */
getch();
}
Dans cette exemple on traite le cas ou une fonction fait appel à une autre fonction.
25/73
Exemple 3
#include <stdio.h>
#include <conio.h>
void carre() /* declaration de la fonction */

{
int n,n2; /* variables locales à carre */
printf("ENTRER UN NOMBRE: ");
scanf("%d",&n);
n2 = n*n ;
printf("VOICI SON CARRE: %d\n",n2);
}
{
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>

{
int n, n2; /* variables locales a carre */
scanf("%d",&n);
n2 = n*n;
}
void cube() /* declaration de la fonction */

{
int n, n3; /* variables locales a cube */
scanf("%d",&n);
n3 = n*n*n;
printf("VOICI SON CUBE: %d\n",n3);
}

{
char choix; /* variable locale a main() */
printf("CALCUL DU CARRE TAPER 2 \n");
printf("CALCUL DU CUBE TAPER 3 \n");
scanf("%c",&choix);
26/73
switch(choix)
{
case '2':carre();break;
case '3':cube();break;
}
printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE: ");
getch();
}
Constatations
Les 2 variables locales n sont indépendantes 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 */

{
int n2; /* variable locale */
scanf("%d",&n);
n2 = n*n;
}
void cube() /* declaration de la fonction */

{
int n3; /* variable locale */
scanf("%d",&n);
n3 = n*n*n;
printf("VOICI SON CUBE: %d\n",n3);
}

{
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();
}
27/73
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 d’en-tête n’a pas changé.
Un programme bien construit possède peu de variables globales.
4. FONCTION RENVOYANT UNE VALEUR AU PROGRAMME ET SANS PASSAGE

D'ARGUMENTS
Dans ce cas, la fonction, après exécution, renvoie une valeur. Le type de cette valeur est déclaré avec
la fonction. La valeur retournée est spécifiée à l'aide du mot réservé 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 général: 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 déclarés 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);
}
28/73
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 différentes.
x est un paramètre, 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 déclarée au début du programme et qu'elle est connue de
tout le programme. Les variables globales sont initialisées à 0 au début de l'exécution du
programme, sauf si on les initialise à une autre valeur.
On a vu aussi qu'une variable locale (déclarée au début d'une fonction ou de main()) n'est connue que
de cette fonction ou de main(). Une variable locale est encore appelée automatique.
Les variables locales ne sont pas initialisées (sauf si on le fait dans le programme) et elles perdent
leur valeur à chaque appel à la fonction.
On peut allonger la durée de vie d'une variable locale en la déclarant static. Lors d'un nouvel appel à
la fonction, la variable garde la valeur obtenue à la fin de l'exécution précédente. Une variable static
est initialisée à 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 paramètre 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.
29/73
Exemple: Fonction permettant d'échanger la valeur de 2 variables:
Syntaxe qui conduit à une erreur: Syntaxe correcte:

#include <stdio.h> #include <stdio.h>
void ech(int x, int y) void ech(int *x, int *y)
{ {
int tampon; int tampon;
tampon = x; tampon = *x;
x = y;
*x = *y;
y = tampon;
} *y = tampon;
void main() }
{ void main()
int a = 5 , b = 8; {
ech(a,b); int a = 5 , b = 8 ;
printf("a=%d\n", a) ; ech(&a,&b);
printf("b=%d\n", b) ; printf("a=%d\n", a) ;
} printf("b=%d\n", b) ;
PASSAGE DES PARAMETRES }
PAR VALEUR 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.
Expérimenter ces deux exemples, noter les résultats obtenus.

Dans un deuxième 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 problème ne se pose pas lorsque le paramètre est un pointeur ou un tableau.
30/73
Année Universitaire : 2009/2010 Semestre : 1

ère
Module : Atelier de programmation I Classe : 1 année LFIAG
Enseignant : Riadh BOUSLIMI
TP n°1
Exercice 1
Ecrire un programme qui saisit 2 entiers et affiche successivement la somme, la différence, le produit
et le quotient de ces 2 entiers.
Exercice 2
Ecrire un programme qui demande à l’utilisateur de donner le rayon d’un cercle et lui retourne sa
surface et son périmètre.
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 réel x et un entier n et affiche x à la puissance n.
Exercice 5
Ecrire un programme qui saisit un caractère c puis affiche son code ASCII en décimal, en octal(base
huit) et en hexadécimal(base seize).
31/73
Correction du TP n°1
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 somme de %d et %d vaut %d",a,b,a+b);

printf("\nLa difference de %d et %d vaut %d",a,b,a-b);
printf("\nLe produit de %d et %d vaut %d",a,b,a*b);
printf("\nLe 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);

}
32/73
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 caractère :");
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
}
33/73

ère
TP n°2
L’objectif du TP c'est d'utiliser la forme adéquate des structures de contrôle conditionnelles pour
résoudre des problèmes.
Exercice 1
Considérez la séquence d'instructions suivante:
if (A>B) printf ("premier choix \n");else
if (A>10) printf ("deuxième choix \n");
if (B<10) printf ("troisième choix \n");
else printf ("quatrième choix \n");
a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if - else
appartenant ensemble.
b) Déterminez les réponses du programme pour chacun des couples de nombres suivants et
vérifiez à 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
34/73
Exercice 2
if (A>B)
if (A>10)
printf ("premier choix \n"); else if (B<10)
printf ("deuxième choix \n"); else
if (A==B) printf ("troisième choix \n");
b) Pour quelles valeurs de A et B obtient-on les résultats:

premier choix, deuxième choix, ... sur l'écran?
c) Pour quelles valeurs de A et B n'obtient-on pas de réponse sur l'écran?
d) Notez vos réponses et choisissez vous-mêmes des valeurs pour A et B pour les vérifier l'aide
de l'ordinateur.
Exercice 3
Ecrivez un programme qui saisit un caractère, 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 entières (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 opérateurs conditionnels et une variable d'aide MAX
d) les opérateurs conditionnels sans variable d'aide
Exercice 5
Ecrivez un programme qui lit trois valeurs entières (A, B et C) au clavier. Triez les valeurs A, B et C
par échanges successifs de manière à obtenir :
val(A) val(B) val(C)
Affichez les trois valeurs.

Exercice 6
Ecrivez un programme qui lit deux valeurs entières (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 entières (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 bibliothèque <math.h> qui
renvoie la valeur absolue d'un flottant.
35/73
Exercice 8
Ecrivez un programme qui calcule les solutions réelles 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 décidez à l'aide de D, si
l'équation a une, deux ou aucune solution réelle.
Utilisez des variables du type int pour A, B et C.
Considérez aussi les cas où l'utilisateur entre des valeurs nulles pour A; pour A et B; pour A, B et C.
Affichez les résultats et les messages nécessaires 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.
36/73
Exercice 1
if (A>B) printf ("premier choix \n"); else
if (A>10) printf ("deuxième choix \n");
if (B<10) printf ("troisième choix \n");
if (A>B)
printf ("premier choix \n");
else
if (A>10)
printf ("deuxième choix \n");
if (B<10)
printf ("troisième choix \n");
else
printf ("quatrième choix \n");
b) Déterminez les réponses du programme pour chacun des couples de nombres suivants et
vérifiez à l'aide de l'ordinateur.
A=10 et B=5 : premier choix
troisième choix
A=5 et B=5 : troisième choix
A=5 et B=10 : quatrième choix
A=10 et B=10 : quatrième choix
A=20 et B=10 : premier choix
quatrième choix
A=20 et B=20 : deuxième choix
quatrième choix
Exercice 2
if (A>B)
if (A>10)
printf ("premier choix \n"); else if (B<10)
printf ("deuxième choix \n"); else
if (A==B) printf ("troisième choix \n");
if (A>B)
if (A>10)
printf ("premier choix \n");
else if (B<10)
printf ("deuxième choix \n");
else if (A==B)
printf ("troisième choix \n");
else
printf ("quatrième choix \n");
37/73
b) Le résultat:
"premier choix" apparaît pour (A>B) et (A>10)
"deuxième choix" apparaît pour (10A>B)
"troisième choix" apparaît pour (10A>B10) et (A=B)

10>10 impossible
A>B et A=B impossible => "troisième choix" n'apparaît jamais
"quatrième choix" apparaît pour (10A>B10) et (AB)

10>10 impossible => "quatrième choix" n'apparaît jamais
c) On n'obtient pas de réponses pour (AB). Si (A>B) alors la construction if - else if - ... - else
garantit que toutes les combinations sont traitées et fournissent un résultat.
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");
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
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();
}
38/73
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) opérateurs 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) opérateurs 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 décroissant 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("Après le tri : \tA = %d\tB = %d\tC = %d\n", A, B, C);
getch();
}
39/73
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 négatif\n", A, B);
else
printf("Le produit %d * %d est zéro\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 négatif\n",A,B);
else
printf("La somme %d + %d est zéro\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 réelles d'une équation du second degré */
int A, B, C;
float D; /* Discriminant */
printf("Calcul des solutions réelles 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;
40/73
/* Distinction des différents cas */
if (A==0 && B==0 && C==0) /* 0x = 0 */
printf("Tout réel est une solution de cette équation.\n");
else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */
printf("Cette équation ne possède 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 réelles.\n");
else if (D==0) /* b^2-4ac = 0 */

{
printf("Cette équation a une seule solution réelle :\n");
printf(" x = %f\n", -B/(2*A));
}
else /* b^2-4ac > 0 */
{
printf("Les solutions réelles 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 numéro 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();
}
41/73

ère
TP n°3
Les objectifs de ce TP c'est de manipuler des structures de contrôle itératives et savoir distinguer
entre les différentes formes (structure itérative complète et structure itérative à condition d'arrêt).
Exercice 1
Saisir une suite de caractères, compter et afficher le nombre de lettres e et d'espaces. Utiliser les
propriétés 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. Résolvez ce problème,
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 entière de deux
entiers entrés au clavier.
Exercice 4
Calculez par multiplications successives XN de deux entiers naturels X et N entrés au clavier.
Exercice 5
Calculez la somme des N premiers termes de la série harmonique :
1 + 1/2 + 1/3 + ... + 1/N
42/73
Exercice 6
Calculez la somme, le produit et la moyenne d'une suite de chiffres non nuls entrés au clavier, sachant
que la suite est terminée par zéro. Retenez seulement les chiffres (0, 1 ... 9) lors de l'entrée des
données et effectuez un signal sonore si les données sortent de ce domaine.
Exercice 7
Calculez le nombre lu à rebours d'un nombre positif entré au clavier en supposant que le fichier
d'entrée standard contient une suite de chiffres non nuls, terminée par zéro (Contrôlez s'il s'agit
vraiment de chiffres).
Exemple: Entrée: 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'entrée standard contient le nombre à inverser.
Exemple: Entrée: 1234 Affichage: 4321

Exercice 9
Calculez le N-ième terme UN de la suite de FIBONACCI qui est donnée par la relation de récurrence:
U1=1 U2=1 UN=UN-1 + UN-2 (pour N>2)
Déterminez le rang N et la valeur UN du terme maximal que l'on peut calculer si on utilise pour UN le
type int.
43/73
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') /* */
lors du 1er passage, getchar ne prend
/* en compte que le 1er caractere*/
{ /* */
les autres sont ranges dans le tampon
if(c=='e')compt_e++; /* et recuperes par getchar lors */
/* des autres passages */
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 données */
int NOMB; /* nombre courant */
int I; /* compteur */
long SOM; /* la somme des nombres entrés */
double PROD; /* le produit des nombres entrés */
printf("Nombre de données : ");

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 %d nombres est %ld \n", N, SOM);

printf("Le produit des %d nombres est %f\n", N, PROD);
printf("La moyenne des %d nombres est %f\n", N, (float)SOM/N);
getch();
}
b) en utilisant do - while, Remplacez le bloc de traitement (en gras) de (a) par :
SOM=0;
PROD=1;
I=1;
do
44/73
{
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 main()
{
int NUM; /* numérateur de la division entière */
int DEN; /* dénominateur de la division entière */
int DIV; /* résultat de la division entière */
int RES; /* reste de la division entière */
printf("Introduisez le numérateur : ");

scanf("%d", &NUM);
printf("Introduisez le dénominateur : ");
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 données */
int I; /* Le compteur */
double RESU; /* Type double à cause de la */
/* grandeur du résultat. */
do
{
printf("Entrez l'entier naturel X : ");
scanf("%d", &X);
}
while (X>=0);
45/73
do
{
printf("Entrez l'exposant N : ");
scanf("%d", &N);
}
while (N<0);
/* Pour N=0, le résultat 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 défini */

if (N==0 && X==0)
printf("zéro exposant zéro n'est pas défini !\n");
else
printf("Résultat : %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 précision du résultat. */
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; /* Le chiffre courant */
int N=0; /* Le compteur des données */
int SOM=0; /* La somme actuelle */
long PROD=1; /* Le produit actuel - Type long à */
/* cause de la grandeur du résultat. */
46/73
do
{
/* Saisie des données (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; /* Le chiffre courant */
int N=0; /* Le compteur des décimales */
long VALD=1; /* Valeur de la position décimale courante */
long NOMB=0; /* Le nombre résultat */
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 remplaçant la ligne
NOMB += VALD*X;
par
47/73
NOMB += pow(10, N)*X;
on n'a plus besoin de la variable VALD. Il faut cependant inclure les fonctions de la bibliothèque
<math>. D'autre part, le calcul de 10N serait alors répété à chaque exécution de la boucle.
Finalement, cette variante est plus lente et plus volumineuse que la première.
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 main()
{
int U1, U2, UN; /* pour parcourir la suite */
int N; /* rang du terme demandé */
int I; /* compteur pour la boucle */
do
{
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;
48/73
U2 = UN;
}
}
printf("Valeur du terme de rang %d : %d\n", N, UN);
getch();
}
Rang et terme maximal calculable en utilisant les déclarations :
int U1, U2, UN; (spéc. de format : %d) U23 = 28657
49/73

Module : Atelier de programmation I Classe : 1ère année LFIAG
TP n°4
Les objectifs de ce TP c'est de manipuler les tableaux et les chaînes de caractères, et d’utiliser les
fonctions prédéfinies pour résoudre des problèmes.
Ce qu'il faut retenir

Bibliothèque (string.h):
void *strcat(char *chaine1, char *chaine2) concatène les 2 chaînes, résultat 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 chaîne et, renvoie l'adresse de la chaine inversée.
int strcmp(char *chaine1,char *chaine2) renvoie un nombre:
o positif si la chaîne1 est supérieure à la chaine2 (au sens de l'ordre alphabétique)
o négatif si la chaîne1 est inférieure à la chaîne2
o nul si les chaînes sont identiques.
void *strcpy(char *chaine1,char *chaine2) recopie chaine2 dans chaine1 et renvoie l'adresse de chaîne1.
Ces fonctions renvoient l'adresse de l'information recherchée en cas de succès, sinon le pointeur NULL (c'est à dire le
pointeur de valeur 0 ou encore le pointeur faux).
void *strchr(chaine,caractère) recherche le caractère dans la chaîne.

void *strrchr(chaine,caractère) idem en commençant par la fin.
void *strstr(chaîne,sous-chaîne) recherche la sous-chaine dans la chaîne.
Bibliothèque (stdlib.h):
int atoi(char *chaîne) convertit la chaîne en entier

float atof(char *chaine) convertit la chaîne en réel
exemple: printf("ENTRER UN TEXTE: ");

gets(texte);
n = atoi(texte) ;
printf("%d",n); /* affiche 123 si texte vaut "123" */
/* affiche 0 si texte vaut "bonjour" */
void *itoa(int n,char *chaîne,int base) convertit un entier en chaîne:
50/73
base: base dans laquelle est exprimé le nombre,
cette fonction renvoie l'adresse de la chaîne.
exemple: itoa(12,texte,10); texte vaut "12"
Exercice n°1
É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 entrées au clavier et affiche le tableau. Calculer et
afficher ensuite la somme des éléments du tableau.
Exercice n°2
Écrire un programme qui calcule le produit scalaire de deux vecteurs d'entiers U et V (de même
dimension).
Exemple:
/ \ / \
| 3 2 -4 | * | 2 -3 5 | = 3*2+2*(-3)+(-4)*5 = -20
\ / \ /
Exercice n°3
Écrire un programme qui détermine 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 n°4
Problème: Rechercher dans un tableau d'entiers A une valeur VAL entrée au clavier. Afficher la
position de VAL si elle se trouve dans le tableau, sinon afficher un message correspondant. La
valeur POS qui est utilisée pour mémoriser la position de la valeur dans le tableau, aura la valeur -
1 aussi longtemps que VAL n'a pas été trouvée.
Implémenter deux versions:
a) La recherche séquentielle
Comparer successivement les valeurs du tableau avec la valeur donnée.
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é, arrêter le traitement avec un message
correspondant.
si la valeur recherchée précède la valeur actuelle du tableau, continuer la recherche
dans le demi-tableau à gauche de la position actuelle.
si la valeur recherchée 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 n°5
Ecrire un programme qui demande l'introduction du nom et du prénom de l'utilisateur et qui
affiche alors la longueur totale du nom sans compter les espaces. Employer la fonction strlen.
Exemple:
51/73
Introduisez votre nom et votre prénom: HSINI Sana
Bonjour HSINI Sana !

Votre nom est composé de 9 lettres.
Exercice n°6
Écrire un programme qui lit 5 mots, séparés par des espaces et qui les affiche ensuite dans une
ligne, mais dans l'ordre inverse.
Les mots sont mémorisés dans 5 variables M1, ... ,M5.
Exemple
voici une petite phrase !
! phrase petite une voici
Exercice n°7
Écrire un programme qui lit une ligne de texte (ne dépassant pas 200 caractères) la mémorise dans
une variable TXT et affiche ensuite:
a) la longueur L de la chaîne.
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, après avoir inversé l'ordre des caractères dans TXT:
Exemple :
voici une petite phrase !
! esarhp etitep enu iciov
Exercice n°8
Ecrire un programme qui lit un texte TXT (de moins de 200 caractères) et qui enlève toutes les
apparitions du caractère 'e' en tassant les éléments restants. Les modifications se feront dans la
même variable TXT.
Exemple:
Cette ligne contient quelques lettres e.
Ctt lign contint qulqus lttrs .
Exercice n°9
Ecrire un programme qui lit un verbe régulier en "er" au clavier et qui en affiche la conjugaison au
présent de l'indicatif de ce verbe. Contrôlez s'il s'agit bien d'un verbe en "er" avant de conjuguer.
Utiliser les fonctions gets, puts, strcat et strlen.
Exemple:
Verbe : fêter
je fête tu fêtes il fête nous fêtons vous fêtez ils fêtent
Exercice n°10
Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2, les compare
lexicographiquement et affiche le résultat:
Exemple:
Introduisez la première chaîne: ABC
Introduisez la deuxième chaîne: abc
"ABC" précède "abc"
52/73
Exercice n°11
Écrire un programme qui permet de vérifier 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
caractères. Exemple : “aziza”
53/73
CORRECTION DU TP N°4
Exercice n°1
#include<stdio.h>
#include<conio.h>
void main()
{
/* Déclarations */
int T[50]; /* tableau donné */
int N; /* dimension */
int I; /* indice courant */
long SOM; /* somme des éléments - type long à cause */
/* de la grandeur prévisible du résultat. */
/* Saisie des données */

do{
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
}while(N>=1 && N<=50);
for (I=0; I<N; I++)

{
printf("Elément %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 résultat */
printf("Somme de éléments : %ld\n", SOM);
getch();
}
Exercice n°2
#include<stdio.h>
#include<conio.h>
void main()
{
/* Déclarations */
int U[50], V[50]; /* tableaux donnés */
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("** Deuxième tableau **\n");
for (I=0; I<N; I++)
{
54/73
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 n°3
#include<stdio.h>
#include<conio.h>
void main()
{
/* Déclarations */
int A[50]; /* tableau donné */
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 n°4
a) La recherche séquentielle :
Comparer successivement les valeurs du tableau avec la valeur donnée.
#include<stdio.h>
#include<conio.h>
void main()
{
/* Déclarations */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */
55/73

do{
scanf("%d", &N );
}while(N>=1 && N<=50);
for (I=0; I<N; I++)

{
scanf("%d", &A[I]);
}
printf("Elément à 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 recherchée 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()
{
/* Déclarations */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */
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("Elément à 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 */
56/73
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 recherchée 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 séquentielle, il faut traverser tout le tableau avant de trouver la
valeur ou avant d'être sûr qu'une valeur ne se trouve pas dans le tableau.
Lors de la recherche dichotomique, on élimine la moitié des éléments du tableau à chaque exécution
de la boucle. Ainsi, la recherche se termine beaucoup plus rapidement.
La recherche dichotomique devient extrêmement avantageuse pour la recherche dans de grands
tableaux (triés) : L'avantage de la recherche dichotomique par rapport à la recherche séquentielle
monte alors exponentiellement avec la grandeur du tableau à trier.
Exemple:
Lors de la recherche dans un tableau de 1024 éléments:
- le pire des cas pour la recherche séquentielle peut entraîner 1024 exécutions de la boucle.
- le pire des cas pour la recherche dichotomique peut entraîner 10 exécutions de la boucle.
Lors de la recherche dans un tableau de 1 048 576 éléments:
- le pire des cas pour la recherche séquentielle peut entraîner 1 048 576 exécutions de la boucle.
- le pire des cas pour la recherche dichotomique peut entraîner 20 exécutions de la boucle.
Exercice n°5
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main(){
{
char NOM[40], PRENOM[40];
printf("Introduisez votre nom et votre prénom: \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();
57/73
}
Exercice n°6
#include <stdio.h>
#include <conio.h>
void main()
{
char M1[30], M2[30], M3[30], M4[30], M5[30];
printf("Entrez 5 mots, séparés 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 n°7
#include<stdio.h>
#include<conio.h>
void main()
{
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I,J; /* indices courants */
int L; /* longueur de la chaîne */
int C; /* compteur des lettres 'e' */
int AIDE; /* pour l'échange des caractères */

printf("Entrez une ligne de texte (max.200 caractères) :\n");
gets(TXT); /* L'utilisation de scanf est impossible pour */
/* lire une phrase contenant un nombre variable de mots. */
/* a) Compter les caractères */

/* La marque de fin de chaîne '\0' est */
/* utilisée comme condition d'arrêt. */
for (L=0; TXT[L]; L++)
;
printf("Le texte est composé de %d caractères.\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 caractères */

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();
}
58/73
Exercice n°8
#include <stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I,J,N; /* indices courants */
printf("Entrez une ligne de texte (max.200 caractères) :\n");
gets(TXT);
/* Eliminer les lettres 'e' et comprimer : */
/* Copier les caractères de I vers J et incrémenter J */
/* seulement pour les caractères différents de 'e'. */
N=strlen(TXT);
I=0; J=0;
while(I<N)
{
if (TXT[I] != 'e'){
TXT[J] = TXT[I];
J++;
}
I++;
}
/* Terminer la chaîne !! */
TXT[J]='\0';
puts(TXT);
getch();
}
Exercice n°9
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
/* Déclarations */
char VERB[20]; /* chaîne contenant le verbe */
char AFFI[30]; /* chaîne pour l'affichage */
int L; /* longueur de la chaîne */

printf("Verbe : ");
gets(VERB);
/* Contrôler 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);
. . .
59/73
AFFI[0]='\0';
strcat(AFFI, "ils ");
strcat(AFFI, VERB);
strcat(AFFI, "ent");
puts(AFFI);
}
getch();
}
Exercice n°10
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main()
{
/* Déclarations */
char CH1[200], CH2[200]; /* chaînes entrées */
int RES; /* résultat de la fonction strcmp */
printf("Introduisez la première chaîne de caractères : "); gets(CH1);

printf("Introduisez la deuxième chaîne de caractères : "); gets(CH2);
/* Comparaison et affichage du résultat */

RES = strcmp(CH1,CH2);
if (RES<0)
printf("\"%s\" précède \"%s\"\n",CH1 ,CH2);
else if (RES>0)
printf("\"%s\" précède \"%s\"\n",CH2 ,CH1);
else
printf("\"%s\" est égal à \"%s\"\n",CH1, CH2);
return 0;
}
Exercice n°11
#include<stdio.h>
#include<string.h>
#include<conio.h>
void main(){
/* Déclarations */
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++;
}
/*
//2ème 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();
}
60/73

Module : Atelier de programmation I Classe : 1ère année LFIAG
TP n°5
Les objectifs de ce TP c'est de comment utiliser les fonctions pour résoudre des problèmes et
Comment déclarer une fonction et comment se fait l'appel de cette dernière?
Exercice n°1
Écrire un programme se servant d'une fonction MOYENNE du type float pour afficher la
moyenne arithmétique de deux nombres réels entrés au clavier.
Exercice n°2
Écrire une fonction MIN et une fonction MAX qui déterminent le minimum et le maximum de
deux nombres réels.
Écrire un programme se servant des fonctions MIN et MAX pour déterminer le minimum et le
maximum de quatre nombres réels entrés au clavier.
Exercice n°3
Écrire la fonction AJOUTE_CH à deux paramètres CH1 et CH2 qui copie la chaîne de
caractères CH2 à la fin de la chaîne CH1 sans utiliser de variable d'aide.
Écrire le programme principale permettant de saisir deux chaînes et de faire appel à la fonction
AJOUT_CH.
Exercice n°4
Écrire la fonction IsPalindrome qui permet de vérifier si le nom en paramètre 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.
61/73
Exercice n°5
Écrire un programme qui permet de remplir un tableau d’entiers de dimension N (tel que N≤50) et
d’afficher les nombres impairs.
NB : Le programme doit comporter au minimum une fonction et deux procédures.
62/73
Exercice n°1
#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 arithmétique de %f et %f est %f\n",
A, B, MOYENNE(A,B));
getch();
}
Exercice n°2
#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 réels : ");
scanf("%lf %lf %lf %lf", &A, &B, &C, &D);
printf("Le minimum des 4 réels est %f \n",
MIN( MIN(A,B), MIN(C,D)) );
printf("Le maximum des 4 réels est %f \n",
MAX( MAX(A,B), MAX(C,D)) );
getch();
63/73
Exercice n°3
Ou aussi
#include<stdio.h>
#include<conio.h>
#include<string.h>
void AJOUTE_CH(char *CH1, char *CH2) void AJOUTE_CH1(char *CH1, char *CH2)
{ {
while (*CH1) /* chercher la fin de CH1 */ int i,n1,n2;
CH1++; n1=strlen(CH1);
while (*CH2) /* copier CH2 à la fin de n2=strlen(CH2);
CH1 */ for(i=0;i<n2;i++)
{ {
*CH1 = *CH2; CH1[i+n1]=CH2[i];
CH1++; }
CH2++;
}
*CH1='\0'; /* terminer la chaîne CH1 */ CH1[n1+n2]='\0';
} }
void main()
{
char Chaine1[30];
char Chaine2[30];
printf("Entrer chaine n°1:");
gets(Chaine1);
printf("Entrer chaine n°2:");
gets(Chaine2);
AJOUTE_CH(Chaine1,Chaine2);
printf("La nouvelle est chaine 1 est :%s",Chaine1);
}
Exercice n°4
#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();
64/73
Exercice n°5
#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("Elément 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();
}
65/73
Université de Jendouba
Faculté des Sciences Juridiques, Economiques et de Gestion de Jendouba
Classe 1ère année Licence Fondamentale en Informatique Appliquée à la Gestion

Matière Atelier de programmation I
Enseignant Riadh BOUSLIMI
Session Principale (Janvier 2010)
Durée 2 heures
Documents Non autorisés
EXAMEN
Exercice n°1 (4 points)
Écrire un programme qui permet de saisir deux chaines CH1 et CH2, de les concaténer ensembles et d’afficher 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 dernières sont deux dates valides et que Date1≤Date2.
Déterminer et afficher le nombre de jours de différence entre ces deux dates.
Exemple:
Date1=19/12/2008
Date2=05/06/2009
Le nombre de jours de différence est : 168 jours
NB : Les deux dates sont de types char de 10 caractères; pour extraire le jour, le mois et l’année vous devez employer la
fonction prédéfinie atoi de la bibliothèque (stdlib.h) qui permet de convertir une chaine en entier.
exemple: printf("ENTRER UN TEXTE: ");
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 d’afficher le nombre
d’occurrences de CH2 dans CH1.
Exemple:
CH1=être bon en algorithmique est équivalent à être bon en atelier de programmation.
CH2=être bon
Le nombre d’occurrences est : 2
Bonne Chance
66/73
Correction d’examen session principale
Module : Atelier de programmation I – 1LFIAG
Exercice n°1 (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 première chaine
for(i=0;i<LongeurCh1;i++)
ch3[i]=ch1[i];
//copie de la deuxième 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();
}
#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;
}
67/73
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'année 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'année 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'année de Date1
for(i=MM1+1;i<=12;i++)
//nb jours du mois de différences 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 précédent de Date2
for(i=MM2-1;i>=1;i--)
NombreDeJours=NombreDeJours+JJ2+GetNombreJoursDuMois(MM1,AAAA1)-JJ1;
}
printf("\n Le nombre de jours de différences est %d \n",NombreDeJours);
getch();
}
68/73
#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();
}
69/73
Université de Jendouba
Faculté des Sciences Juridiques, Economiques et de Gestion de Jendouba
Classe 1ère année Licence Fondamentale en Informatique Appliquée à la Gestion

Matière Atelier de programmation I
Enseignant Riadh BOUSLIMI
Session Contrôle (Juin 2010)
Durée 2 heures
Documents Non autorisés
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 d’afficher le résultat à l’écran.
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≤ note≤20),
dont la dimension du tableau est 5≤n≤30. On suppose que les notes ont le même coefficient.
De calculer la moyenne et d’afficher le résultat à l’écran.
Exemple:
14 12.5 6.25 13.75 11.5 T
0 1 2 3 4
La moyenne est : 11.6

Écrire un programme qui permet de saisir deux chaines CH1 et CH2, d’extraire de ces dernières que
les chiffres, d’effectuer la somme des deux nombres et enfin afficher le résultat à l’écran.
Exemple:
CH1= "N5jrt23fe6K" nb1 = 5236
CH2= "p3Y2" nb2 = 32
La somme des deux nombres est : 5268
NB : vous devez employer la fonction prédéfinie atoi de la bibliothèque (stdlib.h) qui permet de
convertir une chaine en entier.
exemple: ch="12" ;
nb = atoi(ch) ; /* nb=12 */
Bonne Chance
70/73
Correction d’examen session contrôle
Module : Atelier de programmation I – 1LFIAG

#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++; /* incrémentation 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();
}

#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;
}
71/73
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();
}
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <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 numérique */
}
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();
}
72/73
B ibliographie
Achille Braquelaire
Méthodologie de la programmation en C
2ème édition, septembre 2004 Editions Dunod
Brian W. Kernighan et Dennis M. Ritchie

Le langage C - Initiation à la programmation
Norme ANSI, 2ème édition, 2004
Claude Delannoy
Programmer en langage C - notions de programmation acquises par la pratique
2ème édition, Avril 2002 Editions Dunod
Peter Prinz et Ulla Kirch-Prinz

C précis 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
73/73

Atelier de Programmation I

Загружено:

Сведения о документе

Авторское право

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Atelier de Programmation I

Загружено:

Авторское право:

REPUBLIQUE TUNISIENNE

MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE

Adressé aux étudiants de la 1ère année Licence Fondamentale en

Année Universitaire : 2009-2010

exemples: math.h : bibliothèque de fonctions mathématiques

On ne saurait développer un programme en C sans se munir de la documentation concernant

Les compilateurs Borland C++ ou TurboC++ permettent de compiler et exécuter des

2. ETAPES PERMETTANT L'EDITION, LA MISE AU POINT, L'EXECUTION D'UN

4- Exécution du programme (commande « flèche jaune »).

Résultat après compilation et exécution:

On a introduit dans ce programme la notion d’interface homme/machine (IHM).

Résultat après compilation et exécution:

Dans ce programme, on introduit 3 nouveaux concepts :

3. LES DIFFERENTS TYPES DE VARIABLES

Le langage C distingue plusieurs types d'entiers:

TYPE DESCRIPTION TAILLE MEMOIRE

int entier standard signé 4 octets: - 231 ≤ n ≤231-1

short entier court signé 2 octets: - 215 ≤ n ≤ 215-1

char caractère signé 1 octet : - 27 ≤≤n ≤ 27-1

Numération: En décimal les nombres s'écrivent tels que, précédés de 0x en hexadécimal.

un caractère est un entier de 8 bits

Les caractères alphanumériques s'écrivent entre ‘ ‘

Le caractère 'b' a pour valeur 98 (son code ASCII).

Quelques constantes caractères:

CARACTERE VALEUR (code ASCII) NOM ASCII

'\n' interligne 0x0a LF

#include <stdio.h> /* bibliotheque d'entrees-sorties standard */

Résultat après compilation et exécution:

Un réel est composé - d'un signe - d'une mantisse - d'un exposant

Le langage C distingue 2 types de réels:

TYPE DESCRIPTION TAILLE MEMOIRE

char c; est équivalent à char c = 'A';

Exemple: affichage d'un texte:

printf("BONJOUR"); /* pas de retour à la ligne du curseur après l'affichage, */

Résultat après compilation et exécution:

La fonction printf exige l'utilisation de formats de sortie, avec la structure suivante:

Exemple 5 Affichage d'une variable de type char:

Affichage multiple de structure:

printf("format1 format2 .... formatn",variable1,variable2, .......,variablen);

Résultat après compilation et exécution:

Formats de sortie pour les entiers:

%d affichage en décimal (entiers de type int),

Exercice d'application n°1

d) AUTRES FONCTIONS DE SORTIES

Affichage d'un caractère: La fonction putchar permet d'afficher un caractère:

Affichage d'un texte: La fonction puts permet d'afficher un texte:

Opérateurs arithmétiques sur les entiers: + - * / (quotient de la division) % (reste de la division)

Exemple particulier: char c,d;

Opérateurs logiques sur les entiers:

Exemples: p = n « 3; /* p est égale à n décalé de 3 bits à gauche */

Le langage C autorise des écritures simplifiées pour l'incrémentation et la décrémentation de

i = i+1; est équivalent à i++;

i = i-1; est équivalent à i--;

LES DECLARATIONS DE CONSTANTES

Le langage C autorise 2 méthodes pour définir des constantes.

Exemple: void main()

2ème méthode: définition d'un symbole à l'aide de la directive de compilation #define.

Exemple: #define PI = 3.14159;

7. LES CONVERSIONS DE TYPES

Résultat après compilation et exécution:

On peut utiliser getch de deux façons:

- sans retour de variable au programme:

Exemple: printf("POUR CONTINUER FRAPPER UNE TOUCHE ");

- avec retour de variable au programme:

Exemple: char alpha;

Exemples: char alpha;

Exemple: char alpha;