Mini Projet 1

Mini Projet 1:
Écrire un programme en C permettant de calculer la somme, la différence, le

produit, le rapport de deux réels, la racine carrée ou l’inverse d’un nombre réel à
partir du menu suivant :
1
Mini Projet 2:
Ecrire un programme en C pour afficher une liste de mots dans l'ordre inverse.
Entrée:
*nombre de mots
*Liste de mots
Sortie:
*Liste de mots en ordre inverse
Exemple d’exécution:
Dernier délai : le 26 mai 2021

2
PARTIE2:
INITIATION À LA
PROGRAMMATION C
- Généralités et concepts fondamentaux

- Les tableaux
- Les fonctions
1
Département Informatique
Faculté de sciences – Université Ibn Zohr
Année Universitaire 2020/2021

GÉNÉRALITÉS ET CONCEPTS FONDAMENTAUX
Objectif
 L’objectif est d’initier les étudiants à la programmation à
travers l’utilisation du langage C.
/* le classique programme « Hello World » */
#include <stdio.h>
main()
{
printf ("Hello World \n" ) ;
}
SMC4 Année Universitaire : 2020/2021

GÉNÉRALITÉS ET CONCEPTS FONDAMENTAUX
Exemple de programme
// Ceci est un commentaire en C
/*
Ceci est un commentaire en C
écrit sur plusieurs lignes
*/
#include <stdio.h>
main()
{ int i ;
float x ;
i=5 ;
printf ("Bonjour\n") ;
printf("la valeur de l’entier est : %d\n",i) ;
scanf ("%f", &x) ;
printf("la valeur du réel est : %f ",x);
}

STRUCTURE D'UN PROGRAMME EN LANGAGE C
Analyse de l’exemple
La ligne :
main()
se nomme un "en-tête". Elle précise que ce qui sera décrit à sa suite

est en fait le "programme principal" (main). Lorsque nous
aborderons l'écriture des fonctions en C, nous verrons que celles-ci
possèdent également un tel en-tête ; ainsi, en C, le programme
principal apparaîtra en fait comme une fonction dont le nom (main)
est imposé.
Le programme (principal) proprement dit vient à la suite de cet en

tête. Il est délimité par les accolades "{" et "}". On dit que les
instructions situées entre ces accolades forment un "bloc". Ainsi
peut-on dire que la fonction main est constituée d'un en-tête et d'un
bloc ; il en ira de même pour toute fonction C. 6

Déclarations
 Les deux instructions :
• int i ;
• float x ;
sont des "déclarations".
 La première précise que la variable nommée i est de type int, c'est-à-dire qu'elle est
destinée à contenir des nombres entiers (relatifs). Nous verrons qu'en C il existe plusieurs
types d'entiers.
 L’autre déclaration précise que la variable x est de type float, c'est-à-dire qu'elle est
destinée à contenir des nombres flottants (approximation de nombres réels). Là encore,
nous verrons qu'en C il existe plusieurs types flottants.
 En C, les déclarations des types des variables sont obligatoires et doivent être
regroupées au début du programme (on devrait plutôt dire : au début de la fonction
main). Il en ira de même pour toutes les variables définies dans une fonction ; on les
appelle "variables locales" (en toute rigueur, les variables définies dans notre exemple sont
des variables locales de la fonction main). Nous verrons également (dans le chapitre
consacré aux fonctions) qu'on peut définir des variables en dehors de toute fonction ; on
parlera alors de variables globales. 7

Pour écrire des informations : la fonction printf

L'instruction :
printf ("Bonjour\n") ;
Appelle une fonction "prédéfinie" (fournie avec le langage,
et donc que vous n'avez pas à écrire vous même) nommée
printf. Ici, cette fonction reçoit un argument qui est :
"Bonjour\n"
Les guillemets servent à délimiter une "chaîne de
caractères" (suite de caractères). La notation \n est
conventionnelle : elle représente un caractère de fin de ligne,
c'est-à-dire un caractère qui, lorsqu'il est envoyé à l'écran,
provoque le passage à la ligne suivante.
8

Pour écrire des informations : la fonction printf

L'instruction suivante :
printf("la valeur de l’entier est : %d",i);
ressemble à la précédente avec cette différence qu'ici la

fonction printf reçoit deux arguments. Pour comprendre son
fonctionnement, il faut savoir qu'en fait le premier argument
de printf est ce que l'on nomme un "format" ; il s'agit d'une
sorte de guide qui précise comment afficher les informations
qui sont fournies par les arguments suivants (lorsqu'ils
existent). Ici, on demande à printf d'afficher suivant le format :
"la valeur de l’entier est : %d",i la valeur de i, c'est-à
dire, en fait, la valeur 5.
9

Affichage avec la fonction printf()
La fonction printf() permet non seulement d'afficher du texte, mais
également d'afficher le contenu d'une variable.
Exemple
printf ("La variable a contient %d et la variable b contient %d", a, b) ;
La fonction printf() admet un nombre quelconque d'arguments. Le premier

argument est toujours une chaîne de caractères qui indique comment les
arguments suivants doivent être affichés. La séquence de caractères "%d"
est un spécificateur qui signifie qu'il faut afficher l'argument correspondant
en format décimal. Dans notre exemple le premier %d est remplacé par
l'argument a et le deuxième %d est remplacé par l'argument b.
10

Voici la liste des différents formats utilisables pour la

fonction printf en C:
%c : caractère
%d : Entier signé en notation décimale
%i : Entier signé en notation décimale
%f : Float double en notation flottante
%u : Entier signé en notation décimale

%o : Entier signé en notation octale
%x : Entier signé en notation hexadécimale (%X)
11

Pour lire des informations : la fonction scanf

L'instruction suivante :
scanf ("%f", &x) ;
Est un appel de la fonction prédéfinie scanf dont le rôle est de lire une
information au clavier.
Comme printf, la fonction scanf possède en premier argument un format
exprimé sous forme d'une chaîne de caractères, ici : "%f "
Notez bien qu'ici, contrairement à ce qui se produisait pour printf, nous
n'avons aucune raison de trouver, dans ce format, d'autres caractères que
ceux qui servent à définir un code de format.
La fonction scanf doit être en mesure de ranger la valeur qu'elle aura lue
dans l'emplacement correspondant à cette variable, c'est-à-dire à son
adresse. Effectivement, nous verrons que & est un "opérateur" signifiant 12
"adresse de ".

Les directives à destination du préprocesseur

La première ligne de notre programme :
#include <stdio.h>
Est en fait un peu particulière. Il s'agit de "directive" qui sera prise en compte avant la
traduction (compilation) du programme. Les directives, contrairement au reste du programme,
doivent être écrites à raison d'une ligne par ligne et elles doivent obligatoirement commencer en début
De ligne. Leur emplacement au sein du programme n'est soumis à aucune contrainte (mais une directive
ne s'applique qu'à la partie du programme qui lui succède). D'une manière générale, il est préférable
de les placer au début, comme nous l'avons fait ici.
 Cet directive demande en fait d'introduire (avant compilation) des instructions (en langage C)
situées dans les fichiers stdio.h. Son rôle ne sera complètement compréhensible qu'ultérieurement.
Pour l'instant, notez que, dès lors que vous faites appel à une fonction prédéfinie, il est nécessaire
d'incorporer de tels fichiers, nommés "fichiers en-têtes", qui contiennent des déclarations
appropriées concernant cette fonction : stdio.h pour printf et scanf.
Fréquemment, ces déclarations permettront au compilateur d'effectuer des contrôles sur le nombre et
le type des arguments que vous mentionnerez dans l'appel de votre fonction. 13

ETAPES DE CRÉATION D’UN PROGRAMME
Etapes de création d’un programme
➢ Edition d’un fichier source (avec comme extension .c) à l’aide d’un
éditeur de programme. Cette phase s’appelle édition de programme.
➢ Traduire le programme source (proc.c) en langage machine (binaire) qui
aura pour extension .o (proc.o). Cette phase s’appelle compilation.
➢ Liaison des fichiers objets (.o) qui peuvent être des fichiers de la
bibliothèque standard, des fichiers utilisateurs implémentant des
fonctions utilisées dans proc.o. Cette phase s’appelle édition de liens.
➢ Création de l’exécutable du programme. C’est l’exécutable permet de
lancer le programme.
14

NOTION DE TYPE
Définition
➢ Un type est un ensemble nommé de valeurs, muni
d’opérations sur ces valeurs.
➢ Exemple :
➢ Type Entier (ensemble de tous les entiers relatifs); les opérations
sur le type entier sont : addition, soustraction, multiplication,
division, comparaison,….
➢ Type Personne (ensemble de toutes les personnes). Les
opérations peuvent être : sexe, âge, taille, nom, prénom, …
15

NOTION DE TYPE
Utilité du Type
➢ Vérification du programme
➢ On s’assure dès la compilation que les bonnes opérations sont
exécutées sur les bons types
➢ Contre-exemple : application de la fonction racine carrée sur une
personne
➢ Lisibilité du programme : le type de toutes les variables est connu
➢ Une variable est un nom associé à un contenu stocké en mémoire.
➢ Représentation des valeurs en machine
➢ Le type indique la place en mémoire à réserver pour la variable
➢ La mémoire centrale est un ensemble de « positions binaires »
nommées bits. Les bits sont regroupés en octets (8 bits), et chaque
octet est repéré par ce qu’on nomme son adresse.
16

NOTION DE TYPE
Les types primitifs en C
➢ Les types primitifs sont définis dans le langage, ils correspondent aux
informations élémentaires (entier, caractère, réel…)
➢ Les autres types sont construits par le programmeur en fonction des

besoins (Complexe, Personne, Voiture, …) ou fournit par le langage
(bibliothèque)
➢ Les types primitifs en C se répartissent en trois grandes catégories en

fonction de la nature des informations qu’ils permettent de représenter :
➢ Nombres entiers (mot clé int)
➢ Nombres flottants (mot clé float ou double)
➢ Caractère (mot clé char)
17

NOTION DE TYPE
Les Les
types entiers
types entiersen
en C
C
➢ Le mot clé int représente les nombres entiers relatifs. Un bit est réservé pour
représenter le signe du nombre (0 pour un nombre positif et 1 pour un nombre
négatif)
➢ Les différents types d’entiers
• short int (short) ≥ 16 bits
• int ≥ 32 bits (processeur 32 bits)
• long int (long) ≥ 32 bits
• unsigned short int (unsigned short) ≥ 16 bits
• unsigned int ≥ 32 bits (processeur 32 bits)
• unsigned long int (long) ≥ 32 bits
C prévoit que, sur une machine donnée, on puisse trouver jusqu’à trois
« tailles » différentes d’entiers. Chaque taille impose naturellement ses
limites. Toutefois, ces dernières dépendent, non seulement du mot clé
considéré, mais également de la machine utilisée : tous les int n’ont pas la
même taille sur toutes les machines! 18

NOTION DE TYPE
Les types flottant en C
➢ Le mot clé float ou double représente de manière approchée, une partie des
nombres réels.
➢ Les différents types flottant

▪ float 4 octets
▪ double 8 octets
▪ long double 10 octets
19

NOTION DE TYPE
Les types caractères en C
➢ Le mot clé char représente les caractères en C.

➢ En général le caractère est codé en mémoire sur un octet
➢ L’ensemble des caractères représentables, dépend de l’environnement de

programmation utilisé (la machine ou le compilateur utilisé)
➢ On dispose des lettres majuscules et minuscules, des chiffres, des signes de

ponctuation et des différents séparateurs.
20

LES CONSTANTES
Les constantes
➢ Le mot constantes sont des données dont la valeur ne peut

être modifiée. Elles sont généralement définies en début de
programme. La valeur que la constante contient peut être de
tout type, suivant ce que le langage autorise.
➢ Exemple en C :
➢ Des constantes entières : 48, -25
➢ Des constantes float : 12.43, -0.38
➢ Des constantes double : 4.25E+4
➢ Les constantes char : ‘a’, ‘r’, ‘+’, ‘$’
➢ Le caractère de saut de ligne \n
➢ Le caractère de tabulation \t 21

DÉCLARATION D’UNE VARIABLE
➢ Pour déclarer une variable en langage C, il faut d’abord préciser le type de la

variable, suivi du nom de la variable puis d’un point virgule.
➢ La syntaxe d’une déclaration de variable est la suivante:
type_variable Nom_variable;
➢ Il est possible de déclarer une variable en lui donnant une valeur initiale.
type_variale Nom_variable = Valeur_Initiale;
➢ Il est possible de déclarer plusieurs variables sur une même ligne

type_variale variable1, variable2, ….variableN;
22

INITIALISATION ET CONSTANTES
➢ La directive #define permet de donner une valeur à un symbole :
#define a 10
➢ Il est possible d’initialiser une variable lors de sa déclaration comme :
int a = 10;
➢ Il est possible de déclarer que la valeur d’une variable ne doit pas changer lors de
l’exécution du programme.
Par exemple :
const int x = 20;
23

LES INSTRUCTIONS
❑ Définition
Instruction : c’est l’élément clé du programme informatique car elle permet de spécifier
au processeur l’action à effectuer. Une instruction est généralement composée de deux
éléments :
▪ L’opérateur : l’action à effectuer par le processeur
▪ Le ou les opérandes : une ou plusieurs données sur lesquelles l’opération sera
effectuée.
➢ Les instructions sont généralement séparées les unes des autres par des séparateurs
dépendant du langage de programmation utilisé. La plus part du temps, il s’agit d’un
point-virgule. En langage C, une instruction sera notée comme suit :
instruction;
➢ Il est possible de regrouper plusieurs instructions, dans ce que l’on appelle bloc. Il
s’ agit d’un ensemble d’instructions (suivies respectivement par des séparateurs) et la
plus part du temps comprises entre les accolades { et }.
24

LES INSTRUCTIONS
Un programme est constitué d’une suite d’instructions que la machine doit exécuter.
Celle-ci exécute les instructions au fur et à mesure qu’elle lit le fichier (donc de haut en
bas) jusqu’à ce qu’elle en rencontre une (appelée parfois instruction de branchement) qui
lui indique de se rendre à un endroit précis du programme. Il s’agit donc d’une sorte de
jeu de piste dans lequel la machine doit suivre le fil conducteur et exécute les instructions
qu’elle rencontre jusqu’à ce qu’elle arrive à la fin du programme et que celui-ci s’arrête.
25

LES OPÉRATEURS ET LES EXPRESSIONS
Les opérateurs
 Les opérateurs sont des symboles qui permettent de
manipuler des variables, c’est-à-dire d’effectuer des
opérations, de les évaluer.
les expressions
o Les expressions en langage C peuvent être constituées de variables,
constantes, éléments de tableau et références à des fonctions combinés
entre eux à l’aide d’opérateurs.
26

On distingue différentes catégories d’opérateurs:
• Les opérateurs arithmétiques
• Les opérateurs relationnels et logiques
• Les opérateurs d’affectation
• Les opérateurs d’incrémentation et décrémentation
• Les opérateurs d’affectation élargie
• L'opérateur Cast
• L’opérateur séquentiel
27

De façon générale, une expression est une combinaison d’opérateurs et d’opérandes
dont le résultat est une valeur. L’expression possède une valeur mais peut réaliser une
affectation à une variable. Car les opérateurs d’affectation et d’incrémentation peuvent
non seulement intervenir dans une expression ( qui aura une valeur ) mais agir sur le
contenu des variables.
Exemple:
++i est une expression qui réalise une action: incrémenter la valeur de i. Elle aura
comme valeur, la valeur de i aprés incrémentation.
i = 5 est une expression de valeur 5 qui réalise une action : affecter à i la valeur 5.
k = (i = 5) La valeur de l’expression ( i = 5) est affectée á la valeur de k.
28

LES OPÉRATEURS ARITHMÉTIQUES
On distingue:
a) 5 opérateurs arithmétiques binaires
+ addition
- soustraction
/ division
* multiplication
% reste de division entière (modulo)
• Les opérateurs binaires ne sont définis que sur deux opérandes ayant le
même type : ( int, long int, float, double, long double ). Ils fournissent le
même type que leurs opérandes.
• L` opérateur modulo ( % ) ne peut porter que sur des entiers.
b) Un opérateur unaire : - qui ne porte que sur un opérande.

29

Exemple:
Étant données a et b des variables de type entier de valeurs respectives 10 et 3.
Expression sa valeur
a+b 13
a–b 7
a*b 30
a /b 3
a%b 1
Étant données v1 et v2 deux variables de type flottant et dont les valeurs respectives sont 12.5 et 2.0.
v1 + v2 14.5
v1 – v2 10.5
v1 * v2 25.0
v1 / v2 6.25
Étant donnés c1 et c2 de type caractère représentant respectivement les caractères ‘P’ et ‘T’.
c1 80 ( code ASCII de P)
c2 84 ( code ASCII de T)
c1 + c2 164
c1 + c2 + 5 169
c1 + c2 + ‘5’ 215
30
Le code ASCII du caractère ‘5’ est 53.

LES PRIORITÉS RELATIVES DES OPERATEURS
- ( opérateur unaire ) plus prioritaire
* / %
+ - moins prioritaire
• L’évaluation des expressions arithmétiques suit l’ordre de précédence des

opérateurs.
• Dans le cas où des opérateurs ont des priorités identiques, l’évaluation de
l’expression se fait de gauche à droite.
• L’utilisation des parenthèses dans une expression permet d’altérer les règles de
priorité. Les sous expressions parenthèsées sont évaluées en priorité.
31

LES CONVERSIONS IMPLICITES DANS UN CACUL D’EXPRESSION
Une expression mixte est une expression, dans laquelle interviennent des opérandes
de types différents. Dans une expression mixte, le compilateur met en place des
instructions de conversion de la valeur d’un opérande pour obtenir une expression
dont tous les opérandes ont le même type. Le résultat de la conversion sera exprimée
dans le type de plus haute précision.
On distingue deux types de conversion :
➢ La conversion d’ajustement de type

➢ Les promotions numériques
32

La conversion d’ajustement de type
Une conversion de type suit un certain ordre qui permet de ne pas dénaturer la valeur
initiale.
int → long → float → double → long double
Cet ordre permet de convertir par exemple, int en long ou double ou long double
mais l’inverse n’est pas possible.
Exemple:
int n;
long p;
float x;
L’expression n * p + x sera évaluée suivant ce schéma:

1) Conversion de n en long
2 )Multiplication du résultat par p
3) Le résultat de * est de type long
4) Il sera converti en float
5) Il est additionné á x
33
6) Le résultat de + est de type float

Les promotions numériques
Les opérateurs arithmétiques ne sont pas définis pour le type short et char. Le
langage C prévoit que toute valeur de l’un de ces types apparaissant dans une
expression, est d’abord convertie en int. On parle alors de promotion numérique.
Exemple
Cas du type short:
Si p1 et p2 sont de type short

et x de type float
p1 * p2 + x sera évaluée suivant le schéma qui suit:
Les variables p1 et p2 sont soumises à la promotion numérique short→int

On applique les règles de conversion d’ajustement de type.
34

Les promotions numériques
Cas du type char:
La promotion numérique permet de considérer le code du caractère ( sur 8 bits) comme la

valeur de ce caractère.
Dans ce cas, le langage C confond un caractère avec la valeur ( entier) du code qui le
représente.
Remarque :
La valeur entière associée à un caractère donné n’est pas la même sur toutes les machines.
Exemple
Si c1 est de type char.

L’expression c1 + 1 sera évaluée suivant le schéma suivant:
1) promotion numérique de c1
2) l’additionner à 1.
3) Le résultat sera de type int.
35

LES OPÉRATEURS RELATIONNELS
Les opérateurs relationnels
Le langage C permet de comparer des expressions à l’aide d’opérateurs de comparaison.

Le résultat de la comparaison est une valeur entière de valeur 1 ( si le résultat est vrai) ou 0 ( si le résultat est
faux).
Cette expression faisant intervenir des opérateurs de comparaison , sera alors de type entier et donc pourra
intervenir dans des calculs arithmétiques.
Les opérateurs relationnels sont :
< Inférieur à
> Supérieur à
<= Inférieur ou égal à
>= Supérieur ou égal à
== égal à
!= Différent de
Ils sont classés suivant cet ordre de priorité :
< , > , <= , >= ( plus haute priorité )

36
= = , et != ( moins prioritaire)

Exemples
Exemple 1:
int a,b,c,d;
a<b==c<d
l’expression a < b est de type entier; elle prend la valeur 1 ou 0.
c < d est de type entier; elle prend la valeur 1 ou 0.
Suivant les valeurs de (a < b ) et de ( c< d ) , l’expression donnée aura comme valeur
1 ou 0.
Exemple 2:
int x, y, a;
L’expression x + y < a permet de comparer la valeur de l’expression ( x + y ) et la
valeur de a.
Le résultat sera 1 ou 0.
• Les opérateurs relationnels sont moins prioritaires que les opérateurs

arithmétiques. 37

Exemples
Remarque importante:
Une comparaison peut porter sur 2 caractères
a) cas de comparaison d’égalité:
( l’existence d’une conversion de promotion numérique char → int n’a guère
d’influence).
char c1,c2;
c1 = = c2 est vraie ( a la valeur 1) si c1 et c2 ont la même valeur ou bien c1
et c2 contiennent des caractères de même code ( le même caractère).
a) cas de comparaison d’inégalité:
char c1,c2;
c1 < c2 est vraie si le code du caractère c1 a une valeur inférieure au code du
caractère c2.
Le résultat dépendra du codage employé. 38

LES OPÉRATEURS LOGIQUES
Les opérateurs logiques
Le langage C dispose de 3 opérateurs logiques:

&& et logique
|| Ou
! non
A priori, les opérateurs logiques ne portent que sur des opérandes qui sont eux-
mêmes des expressions logiques.
Mais, ils acceptent des opérandes numériques ( types int et float) avec les règles
de conversion implicites.
Dans ce contexte, on considère que :
La valeur nulle ( 0 ) correspond à faux
toute valeur non nulle correspond à vrai
39

Fonctionnement des opérateurs logiques dans C
Opérande1 opérateur Opérande2 résultat

0 && 0 0
0 && Valeur non 0
nulle
Valeur non && 0 0
nulle
Valeur non && Valeur non Valeur non
nulle nulle nulle
0 || 0 0
Valeur non || 0 Valeur non
nulle nulle
0 || Valeur non Valeur non
nulle nulle
Valeur non || Valeur non Valeur non
nulle nulle nulle
! 0 Valeur non
nulle
! Valeur non 0 40
nulle

Les règles de priorité des opérateurs logiques
! plus prioritaire
&&
|| moins prioritaire
les opérateurs arithmétiques sont plus prioritaires que les opérateurs logiques.
L’opérateurs ! ( non) a une priorité supérieure à celle de tous les opérateurs
arithmétiques binaires et opérateurs relationnels.
41

Exemples
Exemple1:
int a,b,c,d;
a < b && c < d équivaut à (a < b) && ( c < d )
! a == b équivaut à (! a) == b
int n,p;
n && p est accepté par le compilateur
!n est accepté par le compilateur
Remarque:
• Le second opérande de l’opérateur && n’est pas évalué si le premier opérande a été
évalué á 0 car l’expression complète aura la valeur 0 ( faux).
• Le second opérande de l’opérateur || n’est pas évalué si le premier opérande a été

42
évalué à vrai ( valeur non nulle) car l’expression complète aura la valeur 1 (vrai).

Exemples
Exemple 2 :
int i = 7;
float f = 5.5;
char c = ‘w’;
L’expression valeur
( i >= 6 ) && ( c = ‘w’ ) 1
( i >= 6 ) || ( c = = 119 ) 1
(f < 11 ) && ( i > 100 ) 0
( c != ‘p’ ) || ( i + f <= 10 ) 1
Exemple 3 :
int i = 7;
float f = 5.5;
L’expression valeur
f> 5 1
!(f>5) 0
! ( i > f + 1) 0 43

LES OPÉRATEURS D’AFFECTATION
Affectation
L'opérateur d’affectation permet de former des expressions d’affectation .
La partie gauche de l’opérateur d’affectation " = " doit être une lvalue (left value).
lvalue est une expression à laquelle on peut affecter une valeur.
Les variables sont des lvalues.
La partie à droite de l’opérateur est une expression dont la valeur est affectée à la lvalue.
La valeur finale de l’expression d’affectation est la valeur de la lvalue après affectation.
• La priorité de cet opérateur est inférieure à celle de tous les opérateurs arithmétiques et
les opérateurs de comparaison.
• Si les opérandes sont de types différents, il y a conversion systématique de

l’expression dans le type de la lvalue. Cette conversion peut entraîner à une dégradation
de la valeur convertie. Par exemple, une valeur de type float peut être tronquée ( elle
perd sa partie décimale) si elle est affectée à une lvalue de type entier.
44

LES OPÉRATEURS D’AFFECTATION
Exemple
int i ;
int j =3;
i = j + 5 Cette expression évalue d’abord l’expression j +

5 avant d’en affecter la valeur ( 8 ) à la variable i. La valeur
finale de cette expression est 8.
45

LES OPÉRATEURS D'INCRÉMENTATION ET DE DÉCRÉMENTATION
Incrémentation
On distingue deux opérateurs unaires:
L’opérateur d’incrémentation noté ++
L’opérateur de décrémentation noté - -
L’opérateur d’incrémentation noté ++
Il a pour effet d’incrémenter de 1 la valeur d’une variable ( lvalue).

On dit que ++ est:
• un opérateur de pré-incrémentation, s’il est placé à gauche de la "lvalue" sur laquelle il porte. La valeur de
l’expression d’incrémentation est celle de la "lvalue" après incrémentation.
• un opérateur de post-incrémentation, s’il est placé à droite de la "lvalue" sur laquelle il porte. La valeur de
l’expression d'incrémentation est celle de la "lvalue" avant incrémentation.
Exemple:
int i = 5;
i++ équivaut à i = i + 1
i devient égale à 6
la valeur de cette expression est 5
++i équivaut á i = i + 1
i devient égal á 6
la valeur de cette expression est 6.
46

Décrémentation
L’opérateur de décrémentation noté --
De la même manière, cette opérateur sera :
• un opérateur de pré-décrémentation s’il est placé à gauche de la "lvalue" sur laquelle il porte.
La valeur de l’expression décrémentation est celle de la "lvalue" après décrémentation.
• un opérateur de post-décrémentation s’il est placé à droite de la "lvalue" sur laquelle il porte.
La valeur de l’expression décrémentation est celle de la "lvalue" avant décrémentation.
Exemple:
int i = 4 ;
--i équivaut à i = i - 1
i-- équivaut à i = i - 1
47

Priorité
Priorités relatives à ces opérateurs:
Ces opérateurs sont de plus haute priorité que les opérateurs arithmétiques.
Exemple:
int i, j, k ;
L’expression 3 * i++ * j-- + k++ équivaut à 3 * (i++)* (j--) + ( k++).
Si t est un tableau :
t[ i++] = 1 permet d’initialiser tous les éléments du tableau
_ affecte la valeur 1 à t[ 0]
_ puis incrémente de 1 la valeur de i.
48

LES OPÉRATEURS D’AFFECTATION ÉLARGIE
Les opérateurs d’affectation élargie
D’une manière générale, C permet de condenser les affectations de la forme :
lvalue = lvalue opérateur expression
en lvalue opérateur = expression
Ceci concerne seulement les opérateurs arithmétiques.
Liste des opérateurs d’affectation élargie:
+=, -=, *=, /=, %= ( concernant les opérateurs arithmétiques).
Exemple:
int i,k;
i += k équivaut à i = i + k
i *= k équivaut à i = i * k.
49

L’OPÉRATEUR CAST
Casting
Le programmeur peut forcer la conversion d’une expression quelconque dans un
type de son choix à l’aide de l’opérateur "cast ".
Exemple:
int n , p;
(double)(n/p) la valeur de l’expression entière n/p sera

convertie en double.
• Sa priorité est élevée par rapport aux autres opérateurs.

• Toutes les conversions numériques sont réalisables par un opérateur " cast ".
50

L’OPÉRATEUR SÉQUENTIEL
L’opérateur séquentiel : noté ,
Il permet d’exprimer plusieurs calculs successifs au sein d’une même expression.
Exemple1:
L’expression a*b, i + j
évalue a * b
puis i + j
L’éxpression i++, j = i + k
incrémente la valeur de i
puis évalue j = i + k.
L’opérateur séquentiel permet de regrouper plusieurs instructions en une seule.
Exemple2 :
i++, j = i + k, j -- équivaut à i ++;

j = i + k;
j--;
51
SMC4 Année Universitaire 2020/2021

LES INSTRUCTIONS DE CONTRÔLE
Le langage C dispose d’instructions structurées permettant de réaliser :
• Des choix et controles : instructions if…else et switch,

• Des boucles : instructions do…while, while et for.
Syntaxe de l’instruction if
L’instruction if présente deux formes :
if (expression)
instruction_1;
else
instruction_2;
if (expression)
instruction_1;
expression : expression quelconque.

instruction_1 et instruction_2 : instructions quelconques, c’est à dire :
•Simple (terminée par un point-virgule),
•Bloc, 52
•Instruction structurée.

Exemples
int x;
printf("Entrer un entier");
scanf("%d" ,&x);
if (x > 0)
printf("X est positif");
int x;
printf("Entrer un entier");
scanf("%d" ,&x);
if (x>0)
x = x – 1;
else
x = x + 2;
printf("La valeur de x est :%d" ,x); 53

Syntaxe de l’instruction switch
switch (Variable)
{
case Valeur1 : Liste d'instructions;
break;
case Valeur2 : Liste d'instructions;
break;
case ValeursN : Liste d'instructions;
break;
default: Liste d'instructions;
}
"Variable" indique une expression dont la valeur est testée successivement par chacune
des cases.
Le mot clé default précède la liste d'instructions qui sera exécutée si l'expression n'est jamais
égale à une des valeurs.
Le mot clé break indique la sortie de la structure conditionnelle.
54

Exemple
#include<stdio.h>
main()
{
char operation ;
int a=5, b=-7 ;
printf( "Choisir une opération (+ ou - ou *) : " ) ;
scanf("%c",&operation);
switch (operation)
{
case '+': printf("\n a + b = %hd", a+b) ;
break ;
case '-': printf("\n a - b = %hd", a-b) ;
break ;
case '*': printf("\n a * b = %hd", a*b) ;
break ;
default : printf("\n Mauvais choix !") ;
}
}
55

LES INSTRUCTIONS RÉPÉTITIVES
En C, nous disposons de trois structures qui nous permettent la définition de boucles
conditionnelles:
1) la structure : while
2) la structure : do - while
3) la structure : for
Théoriquement, ces structures sont interchangeables, c.-à-d. il serait possible de

programmer toutes sortes de boucles conditionnelles en n'utilisant qu'une seule des trois
structures. Comme en Pascal, il est quand même absolument recommandé de choisir
toujours la structure la mieux adaptée au cas actuel.
La structure while en C
while ( <expression> )
<bloc d'instructions>
• Tant que l'<expression> fournit une valeur différente de zéro, le <bloc d'instructions>
est exécuté.
• Si l'<expression> fournit la valeur zéro, l ’exécution continue avec l'instruction qui suit
le bloc d'instructions. 56
• Le <bloc d'instructions> est exécuté zéro ou plusieurs fois.

Exemple
/* Afficher les nombres de 0 à

9 */
int I = 0 ;
while (I<10)
{
printf("%i \n", I);
I++;
}
57

do – while
La structure do - while est semblable à la structure while, avec la différence suivante :
* while évalue la condition avant d'exécuter le bloc d'instructions,

*do - while évalue la condition après avoir exécuté le bloc d'instructions. Ainsi le bloc
d'instructions est exécuté au moins une fois.
La structure do - while en C
do{
}while ( <expression> );
Le <bloc d'instructions> est exécuté au moins une fois et aussi longtemps que
l'<expression> fournit une valeur différente de zéro.
En pratique, la structure do - while n'est pas si fréquente que while; mais dans certains cas,
elle fournit une solution plus élégante. Une application typique de do - while est la saisie
de données qui doivent remplir une certaine condition:
58

Exemple
float N; #include <stdio.h>

do main()
{ { int i, n, som ;
printf("Introduisez un nombre entre 1 et 10 :"); som = 0 ;
scanf("%f ", &N ) ; i = 0 ; /* ne pas oublier cette "initialisation" */
} do
while (N<1 || N>10); {
printf ("donnez un entier ") ;
scanf ("%d", &n) ;
som += n ;
i++ ; /* incrémentation */
}
while (i<4) ; /* attention, ici, toujours <4 */
printf ("Somme : %d\n", som) ;
}
59

La structure for en C
for ( <expr1> ; <expr2> ; <expr3> )

<bloc d'instructions> <expr1> est évaluée une fois avant le passage de la
boucle. Elle est utilisée pour initialiser les données de
est équivalent à : la boucle.
<expr1> ;
<expr2> est évaluée avant chaque passage de la
while ( <expr2> ) boucle. Elle est utilisée pour décider si la boucle est
répétée ou non.
{
<expr3>; <expr3> est évaluée à la fin de chaque passage de la
} boucle. Elle est utilisée pour réinitialiser les données
de la boucle.
60

Exemples
#include <stdio.h>
main()
int n, tot ; {
int i, n, som ;
for (tot=0, n=1 ; n<101 ; n++)
tot+=n ;
som = 0 ;
for (i=0 ; i<4 ; i++)
printf ("La somme des nombres de 1 à 100 est %d\n", tot) ; { printf ("donnez un entier ") ;
scanf ("%d", &n) ;
som += n ;
}
printf ("Somme : %d\n", som) ;
}
61

LES INSTRUCTIONS BREAK ET CONTINUE
L’instruction Break
Ne peut être utilisée que dans le corps d’une boucle ou d’un "switch " et
provoque la fin de ces instructions.
Exemple:
#include<stdio.h>
main()
{
int l_indice ;
for(l_indice = 1; l_indice<10; l_indice++)
{
if(l_indice == 5){
break; }
printf("%d ", l_indice) ;
}
}
62

LES INSTRUCTIONS BREAK ET CONTINUE
L’instruction Continue
Ne peut être utilisée que dans le corps d’une boucle while, do ou for. Son effet et
d’interrompre l’exécution des instructions de la boucle et de relancer l’évaluation du
test.
Exemple:
#include<stdio.h>
main()
{
int l_indice ;
for(l_indice =1; l_indice<10; l_indice++)
{
if(l_indice == 5)
continue ;
printf("%d ", l_indice) ;
}
}
63

LES TABLEAUX
Définition
 Un tableau (uni-dimensionnel) A est une variable
structurée formée d'un nombre entier N de variables
simples du même type, qui sont appelées
les composantes du tableau. Le nombre de
composantes N est alors la dimension du tableau.
A: ...
N Composantes
En faisant le rapprochement avec les mathématiques,
on dit encore que "A est un vecteur de dimension N"
64

LES TABLEAUX
Exemple
La déclaration
int JOURS[12]={31,28,31,30,31,30,31,31,30,31,30,31};
définit un tableau du type int de dimension 12. Les 12 composantes sont

initialisées par les valeurs respectives 31, 28, 31, ... , 31.
On peut accéder à la première composante du tableau par JOURS[0], à la deuxième
composante par JOURS[1], . . . , à la dernière composante par JOURS[11].
65

LES TABLEAUX
Déclaration et mémorisation
Déclaration
Déclaration de tableaux en C
<TypeSimple> <NomTableau>[<Dimension>];
Exemples
Les déclarations suivantes en C:
int A[25]; ou bien long A[25];
float B[100]; ou bien double B[100];
int C[10];
char D[30];
Mémorisation
En C, le nom d'un tableau est le représentant de l'adresse du premier élément du tableau. Les adresses des autres composantes
sont calculées (automatiquement) relativement à cette adresse.
Exemple:
short A[5] = {1200, 2300, 3400, 4500, 5600};
Si un tableau est formé de N composantes et si une composante a besoin de M octets en mémoire, alors le tableau occupera de
N*M octets. 66

LES TABLEAUX
Initialisation et réservation automatique
Initialisation
Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la liste des
valeurs respectives entre accolades.
Exemples
int A[5] = {10, 20, 30, 40, 50};
float B[4] = {-1.05, 3.33, 87e-5, -12.3E4};
int C[10] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};
Il faut évidemment veiller à ce que le nombre de valeurs dans la liste corresponde à la dimension du tableau.
Si la liste ne contient pas assez de valeurs pour toutes les composantes, les composantes restantes sont
initialisées par zéro.
Réservation automatique
Si la dimension n'est pas indiquée explicitement lors de l'initialisation, alors l'ordinateur réserve
automatiquement le nombre d'octets nécessaires.
Exemples
int A[ ] = {10, 20, 30, 40, 50};
==> réservation de 5*sizeof(int) octets (dans notre cas: 10 octets)
float B[ ] = {-1.05, 3.33, 87e-5, -12.3E4};
==> réservation de 4*sizeof(float) octets (dans notre cas: 16 octets)
int C[ ] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};
==> réservation de 10*sizeof(int) octets (dans notre cas: 20 octets) 67

LES TABLEAUX
Exemples
68

LES TABLEAUX
Accès aux composantes
En déclarant un tableau par:
int A[5];
nous avons défini un tableau A avec cinq composantes, auxquelles on peut accéder par:
A[0], A[1], ... , A[4]
Exemple
Exemple
MAX = (A[0]>A[1]) ? A[0] : A[1];
A[4] *= 2;
En C,
- l'accès au premier élément du tableau se fait par T[0]
- l'accès au dernier élément du tableau se fait par T[N-1]
69

LES TABLEAUX
Affichage et affectation
/* Affichage */
main()
{
int A[5] = {2,4,5,8};
int I; /* Compteur */
for (I=0; I<5; I++)
printf("%d \n ", A[I]);
}
/* Affectation */
main()
{
int A[5];
int I; /* Compteur */
for (I=0; I<5; I++)
scanf("%d ", &A[I]); 70
}

LES TABLEAUX
Exercice
Ecrire 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.
71

Corrigé
#include <stdio.h>
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 */

printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
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 \n", T[I]);
/* 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);
}
72

LES FONCTIONS
Définition
Les fonctions sont les sous programmes du C ; elles permettent
de regrouper des instructions et de lancer leur exécution grâce à
un identificateur. La fonction admet des paramètres et peut
retourner une valeur.
La définition (simplifiée) d’une fonction est composée de deux éléments :

a) Prototype :
Il permet de préciser le type, l’identificateur et les paramètres de la fonction ; c’est
l’entête de la fonction.
Syntaxe :
[type] <identificateur> ([liste des paramètres formels])
La liste est composée de la déclaration des paramètres formels :
<type> <arg1>, type <arg2>, …., <type> <argn>
Si la liste est vide alors elle est remplacée par le mot void.
73

LES FONCTIONS
b) Le corps :
C’est une instruction composée (un bloc).
En résumé, la syntaxe de la définition d’une fonction est :

[type] <identificateur> ([liste des paramètres formels])
{
…
<corps de la fonction>
…
} /* fin de la fonction */
Remarques et précisions
• Les identificateurs d’une fonction ou d’une variable obéissent aux mêmes règles
de construction.
• Le type d’une fonction est déterminé par le type de résultat qu’elle retourne : int,
long int, char, double etc…. Une fonction qui ne renvoie pas de valeur au
programme appelant est de type void. Le type par défaut d’une fonction est int. 74

LES FONCTIONS
Exemple
Type Nom Liste
de fonction de fonction d’arguments
int addition(int x, int y)

Début de fonction
{
int result;
Corps de fonction
result = x+y;
return result;
Fin de fonction
}
75

LES FONCTIONS
Exercice
Ecrire une fonction qui calcule le carré d’un nombre réel.
Définition :
double carré_réel (double lvalue)
{
return lvalue * lvalue ;
}
Appel :
carré_réel(5.6) ;
76

Mini Projet 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Mini Projet 1

Transféré par

Droits d'auteur :

Formats disponibles

Mini Projet 1:

Écrire un programme en C permettant de calculer la somme, la différence, le

Dernier délai : le 26 mai 2021

- Généralités et concepts fondamentaux

Année Universitaire 2020/2021

/* le classique programme « Hello World » */

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

se nomme un "en-tête". Elle précise que ce qui sera décrit à sa suite

Le programme (principal) proprement dit vient à la suite de cet en

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

Pour écrire des informations : la fonction printf

SMC4 Année Universitaire : 2020/2021

Pour écrire des informations : la fonction printf

printf("la valeur de l’entier est : %d",i);

ressemble à la précédente avec cette différence qu'ici la

SMC4 Année Universitaire : 2020/2021

printf ("La variable a contient %d et la variable b contient %d", a, b) ;

La fonction printf() admet un nombre quelconque d'arguments. Le premier

SMC4 Année Universitaire : 2020/2021

Voici la liste des différents formats utilisables pour la

%u : Entier signé en notation décimale

SMC4 Année Universitaire : 2020/2021

Pour lire des informations : la fonction scanf

SMC4 Année Universitaire : 2020/2021

Les directives à destination du préprocesseur

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

➢ Les autres types sont construits par le programmeur en fonction des

➢ Les types primitifs en C se répartissent en trois grandes catégories en

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

➢ Les différents types flottant

SMC4 Année Universitaire : 2020/2021

➢ Le mot clé char représente les caractères en C.

➢ L’ensemble des caractères représentables, dépend de l’environnement de

➢ On dispose des lettres majuscules et minuscules, des chiffres, des signes de

SMC4 Année Universitaire : 2020/2021

➢ Le mot constantes sont des données dont la valeur ne peut

SMC4 Année Universitaire : 2020/2021

➢ Pour déclarer une variable en langage C, il faut d’abord préciser le type de la

type_variale Nom_variable = Valeur_Initiale;

➢ Il est possible de déclarer plusieurs variables sur une même ligne

SMC4 Année Universitaire : 2020/2021

➢ La directive #define permet de donner une valeur à un symbole :

➢ Il est possible d’initialiser une variable lors de sa déclaration comme :

const int x = 20;

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

k = (i = 5) La valeur de l’expression ( i = 5) est affectée á la valeur de k.

SMC4 Année Universitaire : 2020/2021

• L` opérateur modulo ( % ) ne peut porter que sur des entiers.

b) Un opérateur unaire : - qui ne porte que sur un opérande.

SMC4 Année Universitaire : 2020/2021

SMC4 Année Universitaire : 2020/2021

• L’évaluation des expressions arithmétiques suit l’ordre de précédence des

SMC4 Année Universitaire : 2020/2021