Vous êtes sur la page 1sur 61

Cours Algorithmique et

Programmation en C

Université Sultan Moulay Slimane IDRISSI NAJLAE


Faculté des Sciences et Techniques Filière Ingénieur
Béni-Mellal 2009 - 2010
Généralités 1/
• Que désigne le terme « Informatique »?
– Science qui étudie les ordinateurs (partie matériel =
hardware )
– Traitement automatique de l’information (partie logicielle
= software)
• Structure générale d’un ordinateur
1. Unité centrale (micro-processeur) est composée de :
• registres internes destinés à stocker temporairement les
informations à l’intérieur du micro-processeur;
• d’unité arithmétique et logique qui effectue un ensemble
d’opérations;
• d’unité de commande et de contrôle qui permet d’extraire,
d’interpréter et d’exécuter les instructions d’un programme
Suite 2/
N bits
2. Mémoire centrale
0 case mémoire

Données et … …
. …
…programmes
.
.
2M - 1

La mémoire centrale « RAM » permet de stocker les informations à traiter. Elle est
composée d’un ensemble de bits (1 bit = 0 ou 1) dit case mémoire.
Chaque case est identifiée par un numéro dit « adresse »

3. Unités périphériques
1. d’entrée & sortie qui permettent à l’utilisateur de communiquer avec l’ordinateur
(saisie, affichage, …)
2. mémoires auxiliaires qui permettent de stocker les informations en permanence
(disque dur, CD, …)
Codage binaire
• Les informations traitées par une machine sont traduites en informations
binaires (suite de bits de 0 et 1). On parle du ‘codage binaire’.
• Pour une base de numérotation b, un nombre n peut s’écrire sous la
forme: n = Σaibi / 0≤ai<b  i0,m

• Code binaire pur: représente les entiers positifs en base 2. Avec n bits, on
peut coder de 0 à 2n -1;
– exemple: n = 23, b=2 sur 8 bits n = (00010111)2
23 = 2(10+1)+1 = 2( 2 x ( 2 x 2 + 1) + 1) + 1 = 2( 2 x (22+20) + 20 ) + 20 =
2(23 + 21 + 20) + 20 = 1x24 + 0x23 + 1x 22 + 1x21 + 1x20 = (10111)2
• Code complément à 2: représente les entiers négatifs; dans ce cas, on
rajoute la valeur 1 au complément à 1 du nombre à coder;
– exemple : n = -15, b=2 sur 8 bits n = (11110001)2
15 = 2x7 + 1= 2 x (22 + 21 + 20) + 20 = 1x23 + 1x22 + 1x21 + 1x20 =
(00001111)2
(11110000)2 complément à 1
(00000001)2 on rajoute la valeur 1
(11110001)2
donc (-15) = (11110001)2
Partie I

« Algorithmique »
Introduction
• Que signifie le terme « Algorithme»? Problème
– ensemble d’étapes qui permettent de résoudre un
problème donné;
– une suite de règles à appliquer dans un ordre analyse
déterminé afin d’arriver au résultat attendu;
– un algorithme est indépendant des données, de la
machine et du langage de programmation I . algorithme
– Exemple: problème posé = calcul de la moyenne
de 2 entiers
• Analyse: les données fournies = 2 entiers traduction
• Résultat désiré = un nombre qui représente la
moyenne des données
II. programmation
il faut ensuite décrire les étapes qui permettent de
passer des données au résultat (algorithme)
– Saisir deux entiers
– Calculer leur somme Résultat
– Diviser la somme par 2
Méthodologie générale
◊ Comprendre la nature du problème posé et préciser les
données (entrées)
◊ Préciser le(s) résultat(s) désiré(s) (sorties)
◊ Les entrées et les sorties sont des ‘variables’
◊ Déterminer le processus de transformation des données
en résultats
◊ Représentation d’un algorithme Nom_algorithme
1. Organigramme
Représentation graphique de l’enchaînement de la
suite d’instructions relatives à un algorithme donné Entrées

2. Pseudo-code
Représentation textuelle de la solution proposée tests
Squelette d’un algorithme:
– Déclaration de variables (entrées)
– Début résultat1 résultat2
– Bloc d’instructions
– Fin Schéma d’un organigramme
Notion de variables
a. Définition = information à stocker et à utiliser au cours d’un
programme désignée par son nom (identificateur attribué
par un utilisateur) et une étiquette (référence attribuée par
l’ordinateur)
b. Déclaration
Attribuer un nom à une variable au sein d’un programme en précisant
son type
Syntaxe = Variables nom_var en Type
c. Initialisation
Affecter une valeur aux variables à l’aide de l’opérateur 
Syntaxe = nom_var  valeur
d. Types de variables
• Type numérique (entier, réel, …)
• Type alphanumérique (caractères et chaînes de caractères)
• Type booléen (vrai ou faux)
Familles d’instructions 1/
-- Ensemble d’opérations à manipuler sur les différentes variables
a. Affectation
Attribuer une valeur pour initialisation ou modification par l’opérateur 
b. Lecture & écriture
Lire = saisir, introduire des données
Syntaxe : Lire nom_var
Ecrire = exécuter l’affichage à l’écran
Syntaxe : Ecrire « texte explicatif », nom_var
c. Structure de choix
Dans le cas où il existe plusieurs choix correspondants à un certain résultat, on utilise une
structure de choix indiquant quel ensemble doit être exécuté
i. forme simple: si (condition est vraie) alors (exécuter bloc d’instructions 1)
sinon (exécuter bloc d’instructions 2)
finsi
ii. forme complexe: selon que (condition 1) faire (bloc d’instructions 1)
ou que (exécuter bloc d’instructions 2)

ou que (exécuter bloc d’instructions n)
autrement (exécuter bloc d’instructions n+1)
fselon (fin du selon)
Suite 2/
d. Structures de répétition
i. Boucle « pour » : utiliser lorsque le nombre d’opérations ou de répétitions à effectuer est connu d’avance;
Syntaxe : pour nom_var  val_initiale à val_finale faire (bloc instructions)
nom_var Suivant
Exemple : calculer la moyenne d’une classe 
Données = n nombre d’étudiants, nt note de chaque étudiant
Résultat = moyenne de la classe = somme divisée par n
Algo = lire n
S0
Pour i  1 à n
Lire nt
S  S + nt
i Suivant
Ecrire « la moyenne des notes est :», S/n

ii. Boucle « tantque … »: aucune condition sur le nombre d’itérations. Le bloc est exécuté tant que la
condition est vraie. Sinon on s’arrête.
Syntaxe : tantque (condition) faire (bloc instructions)
fintantque
iii. Boucle « répéter …jusqu’à »: ici on répète l’exécution du bloc jusqu’à ce que la valeur de la condition
soit vraie. On s’arrête dans ce cas.
Syntaxe : répéter (bloc instructions) jusqu’à (condition)

iv. Exemple : somme d’une suite d’entiers positifs 

Algo: variables x, s en Entier Algo: variables x, s en Entier


Début Début
s0 s0
x0 x0
tantque x >= 0 faire s  s + x répéter s  s + x
Lire x Lire x
Fintantque jusqu’à (x < 0)
Ecrire « la somme de la suite est : », s Ecrire « la somme de la suite est : », s
fin fin
Tableau logique
and or xor
^ 0 1 v
0 1 0 1
0 0 0 0 0 1 0 0 1
1 0 1 1 1 1 1 1 0

Donner la table de vérité des expressions suivantes :


1. A = (a ^ ¬b) v c = (a v c) ^ (¬b v c)
2. B = (a ^ b) v (a ^ ¬b)

a c avc b ¬b ¬bvc A a b a^b ¬b ¬b^a B


0 0 0 0 1 1 0 0 0 0 1 0 0
1 0 1 1 0 0 0 1 0 0 1 1 1
0 1 1 0 1 1 1 0 1 0 0 0 0
1 1 1 1 0 1 1 1 1 1 0 0 1
Exercices 1/
1. Donner un algorithme qui calcule la somme de deux
entiers
2. Donner un algorithme qui permet d’échanger les valeurs
de 3 variables
3. Donner le type et la valeur des expressions suivantes:
– 2 + 3*2
– -0.5 + 3*5
– Vrai et (faux ou vrai)
– (2 <3) ^(4>5)
4. Traduire les expressions suivantes en pseudo-code:
– X = (2a –bc)/d
– Y = (exp(2*a)/2)
– Z = log(1/1-x)
5. Écrire un algorithme qui calcule à partir d’un réel x et une
valeur positive a, la puissance xa
6. Écrire un algorithme qui retourne la partie entière
inférieure de la racine carrée d’un entier donné m
Suite 2/
7. Écrire un programme qui demande un nombre à l’utilisateur, ensuite il lui répond si c’est
un chiffre pair ou impair

8. Écrire un programme qui lit trois chaînes de caractères puis les retourne triées dans
l’ordre alphabétique inverse

9. Écrire un algorithme qui donne le signe (+/-) du produit de 2 nombres sans le calculer

10. Écrire un programme qui décrémente la valeur d’un produit sachant qu’il n’a pas atteint
sa valeur minimale

11. Écrire un programme qui n’affiche que les valeurs paires d’un dé

12. Écrire un programme qui demande à l’utilisateur de saisir une chaîne de caractères
jusqu’à la lecture du mot « bye ». Dans ce cas, on s’arrête

13. Reformuler ce pseudo-code:


Variables A, N en Réel
Début
A0
N0
ecrire « entrez votre variable N: »
Tantque N >= 0
AN
Lire N
si N > A ecrire « le max est : », N
sinon ecrire « le max est : », A
finsi
fin
Suite 3/
14. Reformuler ce pseudo-code:
Variables x, cptp, cptn en Numérique
Variables rep en caractères
Début
cptp  0
cptn  0
Lire rep
répéter
ecrire « voulez-vous continuer?: »
Lire x
si x >= 0 alors cptp  cptp +1
sinon cptn  cptn + 1
finsi
jusqu’à rep = « non »
Fin

15. Écrire un algorithme qui d’après une valeur initiale affiche les cents chiffres suivants
d’un pas de 2. par exemple, si la valeur est 25 alors les chiffres suivantes seront 27, 29,
… jusqu’à 225

16. Écrire un algorithme qui calcule le factoriel d’un entier N

17. Écrire un algorithme qui affiche la valeur maximale et minimale d’une série de 30
chiffres saisis par l’utilisateur

18. Même algorithme que 17 sauf que le nombre de chiffres à saisir n’est pas connu. On
s’arrête lorsqu’une valeur nulle est saisie
Tableaux
 Un autre type de variable que nous traitons dans cette partie concerne les
variables indicées. IL s’agit de regrouper un ensemble de valeurs portant le
même nom de variable et différenciées par un numéro dit ‘indice’. A chaque fois
que l’on veut insérer, chercher, modifier un élément du tableau, on le fait par le
nom du tableau suivi de l’indice entre (). L’indice débute par défaut à 0;

– Syntaxe : Tableau nom_tableau(taille) en Type


– Exemple : soit Note(10) en Numérique un tableau de réels de taille 10
si je cherche la 3ème note, il suffit d’écrire Note(2)

1. Remplissage et affichage d’un tableau numérique Tableau de caractères


Variables N, i en Numérique
Tableau Tab(N) en Numérique Tableau Tab(7) en caractères
Début Variable i en Entier
« saisie »
Début
Pour i  0 à N-1
Ecrire « saisir la donnée n°=», i Tab(0)  « b »
Lire Tab(i) Tab(1)  « o »
i Suivant
Ecrire « Maintenant, nous allons afficher notre tableau » Tab(2)  « n »
Pour i  0 à N-1 Tab(3)  « j »
Ecrire « la valeur de l’élément : », i
Tab(4)  « o »
Ecrire « est : », Tab(i)
i Suivant Tab(5)  « u »
fin Tab(6)  « r »
Fin
Exercices 1/
19. Écrire un algorithme qui saisi la note d’une matière X pour 30 étudiants; ensuite la note
d’une autre matière Y. Puis calcule la moyenne pondérée de ce module sachant que le
coefficient respectif de X et Y est 4 et 3

20. Écrire un algorithme qui affiche les éléments d’une suite de Fibonacci de taille 15. une
suite de Fibonacci est donnée par F0 = 0; F1 = F2 = 1; Fn = Fn-1 + Fn-2

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377

21. Que fait cet algorithme. Peut-on le réduire?


Tableau Tab(10) en Entier
Tableau Tabn(10) en Numérique
Variables i en Entier
Début
Tab(0)  2
Pour i  1 à 9
Tab(i)  - Tab(i-1) + 1
i Suivant
Pour i  0 à 9
si Tab(i) mod 2 = 0
Tabn(i)  - Tab(i)
sinon
Tabn(i)  Tab(i)
finsi
i Suivant
fin
Tableau dynamique
 Jusqu’ici nous avons traité des tableaux statiques où leur taille maximale
est connue à l’avance. Dans certains cas, cette information dépend des
données à insérer et donc inconnue lors de la déclaration du tableau. Ce
n’est qu’après la saisie par l’utilisateur que cette information devient
disponible. Ainsi, pour l’attribuer au tableau en question, on utilise la
fonction ‘Redim’

 Syntaxe: Redim nom_tableau (taille - 1)

 Exemple :
variables i, N en Entier
Tableau Tab() en Numérique ‘taille non connue’
Début
Écrire « donner la taille du tableau »
lire N
Redim Tab(N-1)
pour i  0 à N-1
Tab(i)  0
i Suivant
Fin
Exercices 2/
22. Écrire un algorithme qui mesure l’amplitude de la marée (différence entre la
pleine et la basse mer), l’insère dans un tableau. Ensuite, affiche la
fréquence des valeurs supérieures et inférieures à la marée moyenne
durant une certaine période

23. Écrire un algorithme qui somme 2 tableaux de même dimension. Est qu’on
peut le faire pour des tableaux de dimensions différentes)

24. Écrire un algorithme qui multiplie un tableau par son inverse

25. Écrire un algorithme qui à partir de 2 tableaux saisis, calcule leur


Schtroumpf S. Le Schtroumpf se calcule en multipliant chaque élément du
1er tableau par chaque élément du 2ème et additionne le tout.
1 2 3

4 5

Le Schtroumpf sera S = 1*4 + 1*5 + 2*4 + 2*5 + 3*4 + 3*5 = 54

26. Écrire un algorithme qui inverse un tableau en gardant la même variable.


Techniques sur les tableaux

I. Tri

Le tri est une opération d’arrangement des valeurs dans un ordre


donné croissant ou décroissant.
A. Tri par sélection
 Il consiste à chercher l’élément le plus petit (le plus grand), le mettre dans la 1ère
(dernière) position. Ensuite, chercher le second le plus petit(grand) et le mettre en
seconde (avant-dernière) position et ainsi de suite jusqu’à ce que le tableau soit trié.
 Le nombre de comparaison nécessaire pour ce tri est N(N-1)/2
 Le nombre d’échange est de l’ordre de N et sa complexité est de O(N2)
 Algorithme :
Tableau Tab(N) en Numérique
Variables i, j, min, c en Entier
Début
pour i  0 à N-1
min  i //on suppose que chaque est un minimum puis on teste sur le reste du tableau
pour j  1 à N-1
si Tab(j) < tab(min) alors
min  j
finsi
j Suivant // fin de la boucle sur j
si min <> i alors // on échange
c  Tab(i)
Tab(i)  Tab(min)
Tab(min)  c
finsi
i Suivant // fin de la boucle sur i
Fin
A. Tri à bulles
 Le tri à bulles consiste à comparer deux éléments successifs du tableau. S’ils sont
dans le bon ordre, on passe aux suivants; sinon, on les permute et on reprend la
comparaison dès le début.
 Algorithme :
Tableau Tab(N) en Numérique
Variables i, c en Entier
Variables test en Booléen
Début
test  vrai
tantque test
test  faux
pour i  0 à N-1
si Tab(i) > tab(i+1) alors
c  Tab(i)
Tab(i)  Tab(i+1)
Tab(i+1)  c
test  vrai
finsi
i Suivant // fin de la boucle sur i
fintantque
Fin
Techniques sur les tableaux

II. Recherche

Il s’agit de trouver la position ou un élément donné dans un


tableau.
Recherche

1. Recherche séquentielle
Elle consiste à parcourir le tableau dès sa première valeur et tester
élément par élément jusqu’à atteindre celui en question

2. Recherche dichotomique
L’élément à trouver est comparé au milieu du tableau.
S’il est supérieur, la recherche est effectuée sur la partie droite du tableau,
sinon la partie gauche est à traiter. La tableau est supposé trié dans l’ordre
croissant
Exercices

27. Écrire un algorithme qui trie dans l’ordre décroissant un tableau


numérique pour les 2 types de tri sélectif

28. Même exercice pour le tri à bulles

29. Donner l’algorithme de recherche séquentielle et dichotomique pour un


tableau numérique et alphanumérique trié dans l’ordre croissant

30. Même question que (29) sauf que dans ce cas le tableau est trié dans
l’ordre décroissant
Partie II

« Programmation en C »
Introduction
A. Historique:
– 1972 : Dennis M. Ritchie a fondé ses premières origines
– 1978: publication du standard K&R-C (Brian w.Kerrighan)
– 1982: publication du standard ANSI-C
B. Caractéristiques du langage C:
– universel : il est utilisable pour tous types d’application et non spécifique pour un
domaine précis (Fortran  applications scientifiques)
– haut niveau: le langage C est structuré, déclaratif et récursif
– proche de la machine : offre des opérateurs et fonctions proches du langage machine
– portable : un programme en C peut être utilisé sur tout système possédant un
compilateur C
– compilé :
• saisir un texte « programme source » à l'aide d'un programme appelé EDITEUR,
• le traduire en langage machine (en codes binaires) : c'est la compilation et, si
plusieurs modules ont été compilés séparément, l'édition de liens (LINK ou
BIND),
• l'exécuter.
C. Phases de programmation en C:

Fichiers en tête (*.h) Édition



stdio.h
programme source (.c)
math.h
#include<stdio.h>
#include<math.h>
#include …

main() {
Corps à exécuter

}

Compilation

Programme .objet
(.ob)

Bibliothèques pré compilés Édition de liens

math.h
Programme exécutable
(.exe)
Notions de base
• Premier programme en C:
« include »  fonctions standards

#include<stdio.h> directives
#include<math.h>
« define »  définit une constante
#define Pi 3.14
int main(void) { « main »  fonction principale

int a, b, s; déclaration de variables (type nom_var)


s = 0;
printf(“ veuillez saisir deux entiers”); Instructions (affichage, lecture,
scanf(“ %d, %d: ”, &a, &b); affectation,…)
bloc d’instructions
s = a + b;
printf(“ la somme des deux entiers est %d\n”, s);
return 0;
valeur de retour pour la fonction « main »
}
• Déclaration de variables :
– Syntaxe : <Type> <liste des identificateurs> (nom attribué aux variables
commençant par une lettre et suivi de caractères et de chiffres)
– Le C distingue entre les minuscules et les majuscules
– Les mots clés suivants sont des identificateurs réservés par le système:
• auto, break, case, char, continue, default, do, double, else, enum, extern, float, for, goto, if, int,
long, register, return, short, sizeof, static, typedef, switch, unsigned, void, while, strucy, asm,
large, fortran, far, pascal, near

• Déclaration de fonctions :
– Syntaxe: <type résultat><nom fonction>(<type arg1>, <type arg2>, …, <type
argn>) {
<déclarations locales>; // données utilisées uniquement à l’intérieur de la fonction
<bloc d’instructions>; // liste des instructions qui définissent l’action à exécuter
}
– Fonction « main »:
• Fonction principale pour l’exécution du programme
• Un seul appel main par programme
• Le type du résultat du main est un « int ». Il peut ne pas être déclaré.
• L’instruction « return 0 » signifie que le programme s’est terminé avec succès

• Commentaires en C :
– /* ceci est un commentaire sur plusieurs lignes */
– // ceci est un commentaire sur une seule ligne
Types de base
• Un type définit les valeurs que peut prendre une variable, la taille
mémoire à allouer et les opérateurs que l’on peut appliquer dessus;
1. Les types entiers:
– 4 variables du type « entier » existent en C : les caractères (char), les
entiers courts (short int), les entiers standards (int) et les entiers larges
(long int);
– Un caractère s’identifie à son code ASCII. Ainsi, une variable de type
«char» peut subir les mêmes opérations que les autres entiers;
– Si on ajoute le préfixe « unsigned » à l’une de ces variantes, ceci signifie
que nous sommes entrain de manipuler des entiers non signés (positifs)
Type Valeur Valeur Nombre
minimale maximale d’octets
char -128 127 1

short int -32768 32767 2

int -32768 32767 2

long int -2147483648 2147483647 4


2. Les types réels :
– 3 types réels existent : les réels à simple précision (float), les réels à double
précision (double) et les réels à très grande précision (long double);

Type Précision Nombre de approximation Nombre


chiffres d’octets
significatifs
float simple 6  1.1 10-38à  3.4 1038 4

double double 15 2.2 10-308 à  1.7 1308 8

long double très grande 19 3.4 10-4932 à  1.1 104932 10


3. Déclaration d’une constante :
a) Les constantes entières peuvent être représentées :
 sous la forme standard décimale (134)
 sous la forme octale en les précédant par ‘0’ (0206)
 sous la forme hexadécimale en les précédant par ‘0x’ (0X86)

b) Les constantes réelles peuvent être représentées:


 sous la forme standard décimale (101.34)
 sous la forme exponentielle (1013.4 e-1 ou 10134 e-2)

c) Les caractères constants


 Une constante caractère est indiquée entre apostrophes (‘a’, ‘b’)

d) Les chaînes de caractères constantes


 Une constante chaîne de caractères est indiquée entre guillemets (‘’chaîne’’,
‘‘bonjour’’)

e) L’opérateur (const)
 pour fixer une valeur d’une variable, on utilise l’attribut « const »
• const int a = 10; // la valeur de a ne change pas au cours du programme
Caractères de signification
contrôle
‘\a’ bip sonore

‘\b’ retour arrière

‘\t’ tabulation horizontale

‘\n’ retour à la ligne

‘\\’ antislash

‘\o’ caractère nul

‘\?’ point d’interrogation

‘\’’ apostrophe

‘\’’’ guillemets

‘\f’ saut de page

‘\v’ tabulation verticale

‘\nombre’ nombre en octale

‘\xnombre’ nombre en hexadécimale


Opérateurs standards
1. Opérateurs classiques:
a. Affectation  <variable> = <nouvelle expression>;
 int a = 5, b=2, c; //initialisation et affectation
 c = a + b; //affectation avec autres valeurs
b. Opérateurs arithmétiques  <+, -, /, %>
 L’opérateur «%» permet d’obtenir le reste de la division entière (mod)
 L’opérateur «/» retourne le quotient entier des deux opérandes
c. Opérateurs logiques  <&& (and), || (ou), ! (négation)>
 S’appliquent à des expressions logiques (vrai ou faux) (cf. tableau logique,
1ère partie)
 Exemple:
• (2>3) && 40 vaut 0
• !!1 vaut 1
d. Opérateurs de comparaison  < ==, !=, <, >, <=, >= >
 0 si la comparaison est fausse, 1 sinon
 Exemple:
• 0 || (32 >12) vaut 1
• 0 || !(32 >12) vaut 0
e. Les opérateurs de bits  < >>, << >
 a << (>>) b
 Les opérandes sont de type entier (char, short int, int, long int);
 L’opérande à gauche a est l’objet à décaler; (conversion en binaire)
 L’opérande à droite b représente le nombre de bits de décalage
 Si l’entier à décaler est signé alors le bit signé (position binaire d’extrême
gauche) est préservé lors du décalage à droite
 Si l’entier à décaler est non signé, alors les bits laissés libres sont mis à 0;
 Exemple :
• int i, j;
• i= 5; // i en binaire (0000 0101)
• j = i<<2; /* j après décalage (00010100) = 20 */
• j = i>>2; /* j après décalage (00000001) = 1 */
• i = - 3; /* i en binaire (11111101) */
• j = i <<2; /* j devient (11110100) = -15 */
• j = i >>2; /* j devient (11111111) = -1 */
f. Les opérateurs bit à bit  < &, |, ^>
 Les opérateurs portent sur les bits du même rang
 Exemple :
• int i = 5, j = -3 ;
• i & j vaut 5
• i | j vaut -3
• i ^ j vaut -15
2. Opérateurs particuliers de C:
a. Opérateur d’affectation  <+=, -=, /=, %=, <<=, >>=, &=, |=, ^= >;
 opérande1 = opérande1 op opérande2 <==> opérande1 op= opérande2
 Exemple:
• a = a /b  a /= b;
• c = c >> 2  c >>= 2
b. Opérateurs d’incrémentation et de décrémentation  <++, -->
 post-incrémentation (décrémentation) <variable>++(--)
 La valeur de « variable » est d’abord utilisée puis incrémentée
(décrémentée)
 pré incrémentation (décrémentation) (- -)++<variable>
 La valeur de « variable » est d’abord incrémentée (décrémentée) puis
utilisée
 Exemple:
 int a = 3, b = 0;
 Que vaut a++ et ++b?

c. Opérateur conditionnel <?:>


 <expression>?<expression1>:<expression2>
 L’expression est évaluée. Si sa valeur est vraie, alors c’est la valeur de
l’expression1 qui est retournée sinon, c’est l’expression2
 Exemple: max = i>j ? ‘matin’: ‘soir’
d. Opérateur séquentiel  <expression1, expression2>
 Cet opérateur permet de regrouper deux sous expressions en une seule. On
évalue la première puis la seconde. La valeur finale retournée de l'expression
étant la seconde.
 On peut aussi l'utiliser pour évaluer deux (ou plus) expressions en même temps

e. Opérateur sizeof  sizeof(<variable || type>)


 retourne le nombre d’octets qu’occupe un type ou variable
 sizeof(float) retourne 4 octets

f. Opérateur de forçage de type (cast)


 (type) <variable>
 convertit la variable d’un type donné en le type spécifié (type)
3. Priorité et associativité des expressions
Lors de l’évaluation des expressions, les opérateurs respectent certaines lois
de priorité et d’associativité;
Lecture et écriture de données
1. Écriture formatée des données  printf
printf(‘’format’’, <expr1>, <expr2>, …, <exprn>);
a. La partie « format » est une chaîne de caractères qui peut contenir:
• du texte;
• des caractères de contrôle;
• des spécificateurs de format
b. Un spécificateur indique la manière dont les valeurs des expressions
<expr1>,…,<exprn> seront affichées
c. Un spécificateur par expression, il commence par le symbole ‘%’ et se termine par 1
ou 2 caractères qui indiquent le format d’affichage
d. On peut indiquer la largeur minimale du champ où sera affichée la valeur. La forme
est donnée par :
%[ [-] <n1>] [.<n2>] <spécificateur> avec:
• « - » : aligne l’affichage sur la gauche
• « n1> : taille minimale du champ d’affichage
• « n2 » : dans le cas des réels, n2 indique le nombre de chiffres à afficher
après la virgule
2. Lecture formatée des données  scanf
scanf (‘’format’’, <add var1>,…, <add varn>);
a. Le scanf lit le fichier standard en entrée « stdin » puis fait correspondre les
caractères lus au format indiqué dans la chaîne de « format »;
b. La spécification du format est identique à printf sauf qu’on fournit l’adresse
(&) des variables suivi de leurs identificateurs

Tableau de spécificateur de format


spécificateur affichage type

%c un seul caractère char

%d ou %i un entier relatif int

%u un entier non signé unsigned int

%o un entier en octale int

%x un entier en hexadécimale(a-f) int

%X un entier en hexadécimale(A-F) int

%f un réel float ou double

%e un réel en exponentiel (e) ``

%E un réel en exponentiel (E) ``

%s une chaîne de caractères *char


Exemples
1. Donner l’ordre et la valeur d’évaluation des expressions suivantes:
– a=5, b= 10, c = -1;
– X = 2*a + 3*b – 4*c;
– a = b = c;
– a *= b += 5;
– !- -a == ++ !b;
– ((2*a + 3)*b – 4)*c;
2. Donner le type des expressions suivantes:
– int x = 4,y; float z = 15. 76; char c;
– A = x*z + y;
– c = c + 1;
– y = z/x;
– (float)y = (float)z/x;
3. Quel est le résultat des instructions suivantes:
– printf(‘‘%4d’’, 14297);
– printf(‘‘%4x’’, 142);
– printf(‘‘%f’’, 1429.7);
– printf(‘‘%.2f’’, 14.297);
– printf(‘‘%4f’’, 142.97);
Lecture et écriture d’un caractère
1. Écriture d’un caractère  putchar
putchar(caractère)
• Permet d’écrire un caractère sur stdout. Elle est équivalente à printf(‘‘%c’’,
caractère)
• Exemple:
• char a= 63, b = ‘\n’, c= ‘\a’;
• putchar(‘x’);
• putchar(‘\’’);
• putchar(b);
• putchar(66);
• putchar(a);
• putchar(c);
2. Lecture d’un caractère  getchar
caractère = getchar()
• Permet de lire un caractère sur stdin. Elle retourne le caractère lu
Structures de contrôle
1. Structures de choix:
Utilisable lorsqu’on a besoin de n'effectuer certaines instructions que dans
certains cas. On dispose pour cela du « if » et du « switch ».
a. L’instruction « if »
if (expression)
bloc d’instructions1
else
bloc d’instructions2
• Si l’expression est vraie, alors le bloc d’instructions 1 est exécuté sinon c’est le
second bloc;
• Remarques :
– if (!expr) <==> if (expr == 0)
– if (expr1)
if (expr2)
if (expr3)
bloc1
else bloc2
else bloc 3
 Un « else » se rapporte au « if » le plus proche; un « if » peut aussi se terminer
sans « else »
 Exemples :
int a = 0, b=2, n= -1, m = 0;
1. if(n>0)
if(a>b)
m = a;
else
m = b;

2. if(n>0) {
if(a>b)
m = a;
}
else
m = b;

3. Écrire un programme qui permet de résoudre l’équation du second degré


Ax2 + Bx + C = 0;
4. Écrire un programme qui vérifie la validité de l’heure saisie(hh:mm:ss);
5. Écrire un programme qui calcule le chiffre d’affaires d’une entreprise
(recettes – dépenses). Si ce chiffre dépasse les 100000 dhs, l’entreprise
est en bonne état sinon elle souffre d’une crise.
b. L’instruction « switch»
switch (expression) {
case <choix1> : bloc d’instructions1
case <choix2> : bloc d’instructions2

case <choixn> : bloc d’instructionsn
default : bloc d’instructions
}
Le test s’effectue sur la valeur de l’expression, si elle prend la ième valeur, alors on
exécute le ième bloc correspondant
• Exemple : char c;
switch ( c) {
case ‘+’ : puts(‘’opération d’addition’’); break;
case ‘-’ : puts(‘’opération de soustraction’’); break;
case ‘*’ : puts(‘’opération de multiplication’’); break;
case ‘/’ : puts(‘’opération de division’’); break;
default : puts(‘’opération non valide’’); break;
}
• Remarques : l’instruction « break » permet de sortir immédiatement du bloc
exécuté, sinon le switch risque de tester le cas suivant.
2. Structures de répétition:
Utilisable lorsqu’on a besoin de répéter un bloc d’instructions plusieurs fois.
a. La boucle « for »
for (expr1; expr2; expr3)
{ bloc d’instructions }
expr1 : valeur départ;
expr2 : condition d’arrêt;
expr3 : mise à jour de la condition d’arrêt

– On évalue l’expression1, puis on réitère le processus suivant:


– Évaluer l’expression 2; si elle est valide, on exécute le bloc d’instructions puis on
évalue l’expression3; sinon on s’arrête
• Exemple :
– /* affichage du double des valeurs entre 0 et 15 */
int i;
for (i=0; i<=15; i++)
printf(‘’%d\t’’, 2*i);
1. Écrire ce programme en utilisant l’opérateur séquentiel « , » ;
2. Écrire un programme qui calcule pour un nombre compris entre 1 et 10 les cinq
premiers termes de la suite Un définie par :
U0 = une valeur à saisir;
Un = 2Un-1 si n est impair ;
Un-1 + 1 si n est pair;
3. Écrire un programme qui fait le compte à rebours d’une valeur donnée
b. La boucle « while »
while (expr)
{ bloc d’instructions }
Elle correspond à « tantque » (expr) faire « bloc instructions »
– L'expression est au moins évaluée une fois. Tant qu'elle est vraie, on
exécute le bloc d'instructions; dès qu'elle est fausse, on sort du bloc et
on passe aux autres instructions (si elle est fausse dès le début, le bloc
n'est jamais exécuté).
• Exemple :
– /* affichage de la racine des chiffres entre 0 et 10 */
..
float nombre,racine=0;
puts("entrez un nombre réel entre 0 et 10");
scanf("%f",&nombre);
while (racine*racine<nombre) racine+=0.01;
printf("la racine de %f vaut %4.2f à 1%% près\n", nombre, racine);
1. Écrire un programme qui affiche les puissances d’un entier n saisi jusqu’à atteindre une valeur
maximale fixée par l’utilisateur
2. Écrire un programme qui fait le compte à rebours d’une valeur donnée
3. Que fait ce programme?:
int i, j;
puts(« donner le i");
scanf("%d",&i);
puts("entrez un j");
scanf("%d",&j);
while (i != j) {
puts(« donner le i");
scanf("%d",&i);
puts("entrez un j");
scanf("%d",&j);
if (i == j) { printf(‘’votre pivot est
c. La boucle « do … while » (%d,%d)’’, i,j);
break;}
do
}
{ bloc d’instructions }
while (expr)
Elle correspond à faire « bloc instructions » « tantque » (expr)
– Semblable à while mais le bloc d'instructions est au moins exécuté une fois, avant la
première évaluation de l'expression.
• Exemple :
– /* affichage du double des valeurs entre 0 et 15 */
int i;
do
printf(‘’%d\t’’, 2*i);
while (i<0|| i>15)

1. Refaire les mêmes exercices du « while »


2. Écrire un programme d’affichage de menu
3. Branchements inconditionnels :
Utilisable lorsqu’on a besoin de terminer un bloc immédiatement.
a. break
• Il provoque la sortie immédiate de la boucle ou switch en cours. Il est
limité à un seul niveau d'imbrication
b. continue
• Elle permet de passer directement à l’itération suivante d’une boucle
c. return
• Permet de sortir de la fonction actuelle (par exemple main), en se
branchant à son dernier ‘}’.
• Return permet également de rendre la valeur résultat d’une fonction
d. Exit
• Permet de quitter directement le programme
Tableaux
Définition

• Un tableau est une variable structurée formée d’un ensemble de valeurs de


même type dites « composantes du tableau »;

• Le nombre de composantes constitue la « dimension du tableau »;

• Chaque élément est repéré par un « indice » précisant sa position au sein du


tableau;

• Le nom du tableau est « l’identificateur de ce tableau ».


Tableau à une dimension
1. Déclaration :
Syntaxe: <type><nom tableau>[dimension]
• Le « type » détermine le type des différentes valeurs composantes le tableau;
• Le « nom tableau » est l’identificateur du tableau;
• La « dimension » est la taille maximale que peut atteindre ce tableau
• float Note[30];
2. Initialisation :
Syntaxe: <type><nom tableau>[dimension] = {c1,c2,…,cn}
• Si la liste des composantes « c1,…,cn » ne contient pas toutes les valeurs, les
composantes restantes sont initialisées à 0;
• Si la « dimension » n’est pas fixée à l’initialisation, le système alloue
automatiquement l’espace nécessaire.
• float Note[] = {10, 12, 16, 8}
3. Mémorisation :
• Le nom du tableau est le représentant de l’adresse du 1er élément du tableau;
• Les adresses des autres composantes sont calculées relativement à cette adresse;
par exemple, l’adresse du ième élément d’un tableau donné X se calcule par :
X + (i*taille_de_la_composante)
• Pour un tableau formé de N composantes de taille M octets, l’espace total à allouer
pour ce tableau est (N*M) octets.
4. Accès :
• Pour accéder au ième élément du tableau, on utilise son indice selon la syntaxe
suivante:
Syntaxe : nom_tableau[indice-1], avec indice >= 0

5. Exemples :
a. saisie et affichage d’un tableau de réels
#include<stdio.h>
main() {
// déclaration
int i, N;
printf(‘’veuillez saisir une dimension\n’’);
scanf(‘’%d’’, &N);
flaot T[N];
// saisie
for(i=0; i<N; i++) {
printf(‘’l’élément %d\n’’, i);
scanf(‘’%f’’, &T[i]);
}
// affichage
for(i=0; i<N; i++)
printf(‘’%f\n’’,T[i]);
return 0;
}
Tri d’un tableau
1. Tri par sélection
– Il s’agit de parcourir le tableau en cherchant l’élément le plus petit (le plus
grand), le mettre dans la 1ère (dernière) position. Ensuite, procéder à la
recherche du second plus petit(grand) et le mettre en seconde (avant-
dernière) position et ainsi de suite jusqu’à ce que le tableau soit trié.
2. Tri par propagation (bubble sort)
– Il s’agit à comparer les éléments du tableau deux à deux successivement.
S’ils sont dans le bon ordre, on passe aux suivants; sinon, on les permute
et on reprend la comparaison dès le début.

3. Exercices :
– Écrire un programme de tri par sélection et par propagation;
Recherche dans un tableau

1. Recherche séquentielle
– Il s’agit de comparer successivement les valeurs du tableau avec la valeur
donnée
2. Recherche dichotomique
– Décomposer le tableau en 2.
– Comparer la valeur recherchée à celle du milieu; si elle est supérieure, la
recherche est effectuée sur la partie droite du tableau,
– sinon la partie gauche est à traiter.
– La tableau est supposé trié dans l’ordre croissant.

3. Exercices :
– Écrire un programme de recherche séquentielle et dichotomique dans le
cas croissant et décroissant
Tableau à plusieurs dimensions
1. Déclaration :
Syntaxe: <type><nom tableau>[dim1] [dim2]…[dimn]
2. Cas de deux dimensions (matrices)
Syntaxe: <type><nom matrice>[lignes] [colonnes]
• La taille « lignes » représente le nombre maximale de lignes composantes la matrice;
(sens horizontal)
• La taille « colonnes » représente le nombre maximale de colonnes composantes la
matrice; (sens vertical)
• float classe [30][5];
3. Mémorisation :
• Le nom d’une matrice est le représentant de l’adresse du 1er élément(l’adresse de la
1ère ligne);
• Les composantes d’une matrice sont stockées ligne par ligne en mémoire;
• Les adresses des autres composantes sont calculées comme suit :
M + (i* lignes* taille_de_la_composante) + (j* taille_de_la_composante)
• Pour une matrice formée de L lignes et C colonnes de taille M octets, l’espace total à
allouer est (L*C*M) octets.
4. Accès :
• Pour accéder à l’élément (i,j) d’une matrice, on utilise ses indices selon la syntaxe
suivante:
Syntaxe : nom_matrice[i] [j]
5. Exemples :
a. saisie et affichage d’une matrice de réels
#include<stdio.h>
main() {
// déclaration
int i, j, L, C;
printf(‘’veuillez saisir un nombre de lignes\n’’);
scanf(‘’%d’’, &L);
printf(‘’veuillez saisir un nombre de colonnes’’);
scanf(‘’%d’’, &C);
flaot M[L][C];
// saisie
for(i=0; i<L; i++)
for (j=0; j;C; j++) {
printf(‘’l’élément [%d,%d]\n’’, i,j);
scanf(‘’%f’’, &M[i][j]);
}
// affichage
for(i=0; i<L; i++)
for (j=0; j;C; j++)
printf (‘’%f\t’’, M[i][j]);
return 0;
Pointeurs
Fonctions
Chaînes de
caractères
Structures