Cours

– Types, Operateurs,Conditions, Boucles
Programmation en langage C
C à été conçu en 1972 par Dennis
Ritchie et Ken Thompson, chercheurs
aux Bell Labs, afin de développer un
système d’exploitation UNIX.
2
Programmation en langage C,ISET’COM
• Il faut sauvegarder cefichier #include <stdio.h>
et lui donner un nom;
int main (void) // le fonction main()
• on l’appellera ”prem.c”par {
exemple. printf (˝Bonjour tout le monde !˝) ;
return (0) ;
• Il faut compiler ceprogramme }
pour le transformer en code
objet. Code exécutable par la
machine: gcc prem.c -o prem
• L’exécution du programme se
fait en tapant dans le console:
▪ ./prem
• L’ordinateur affichera alors:
Bonjour tout lemonde!
Programmation en langage C, ISET’COM 3

• Il faut sauvegarder cefichier
et lui donner un nom; on
Importation des bibliothèques l’appellera ”prem.c”par
exemple.
#include <stdio.h> • Il faut compiler ceprogramme
pour le transformer en code
int main (void) // le fonction main() objet. Code exécutable par la
{
printf (˝Bonjour tout le monde !˝) ; machine: gcc prem.c -o prem
return (0) ;
}
• L’exécution du programme se
fait en tapant dans le console:
▪ ./prem
Corps du programme • L’ordinateur affichera alors:
Bonjour tout lemonde!

• Un programme en langage C est constitué des six
groupes de composants élémentaires suivants :
• les identificateurs
• les mots-clefs
• les constantes
• les chaînes de caractères
• les opérateurs
• les signes deponctuation

LES
COMMENTAIRES
• Le compilateur ignore les
commentaires
/* Voici mon premier programme C que
j’ai écrit le vendredi 8 septembre
2017 */
• Deux sorts decommentaires
• Multi-lignes
#include <stdio.h>
• Un seul ligne
int main (void) // le fonction main()
{
printf (˝Bonjour tout le monde !˝) ;
return (0) ; • Il n’est pas possible d’imbriquer
} des commentaires
/*ceci /* est un commentaire */ */

• Dans un programme C les variables, les
fonctions, les types etc. sont désignés par un Ligne_lig
nom qu’on appelle identificateur val_5
• Suite de caractères ( lettres, chiffres ou _ ) _total
qui commence par une lettre ou _ _91
• Les lettres accentuées sont à éviter : certains

compilateurs les acceptent d’autresnon
• Attention, le C fait la différence entre
minuscule et majuscule :
Ligne_lig ≠ ligne_lig

• Les mots réservés par la langage
• Langage C a 32 mots-clés
• Ils ne peuvent pas être utilisés comme identificateurs
auto const break continue

case default char do
double float int else
for long enum goto
register extern if return
short signed sizeof static
struct switch typedef union
unsigned void volatile while

• Le C est un langage typé
Types Valeurs Octets
• Un type définit un ensemble
• char Un caractère 1 de valeurs et d'opérations qui
• int Nombres entiers 4 peuvent être effectuées sur
• short Nombres entiers 2 celui-ci
• long int Nombres entiers 8 • Le type int peut représenter
• float Nombres réelles 4 les nombres entiers compris
• double Nombres réelles 8 entre: -2147483648 et
• void Pas de type 0 +2147483647
• Un type spécial appelévoid
explique qu'aucun type ne
peut décrire les données
• Booléen
• n’existe pas
• une valeur entier non zéro est considérée vraie
• une valeur entier zéro est traitée comme fausse
• Chaîne de caractères
• n’existe pas
• on utilise des tableaux de caractères.
• Unsigned
• Un int peut représenter un entier entre −2 31 et (231 − 1). L’attribut
unsigned spécifie que l’entier n’a pas de signe. Un unsigned int
peut donc représenter un entier entre 0 et (232 − 1).

• L’opérateur sizeof permet de connaître la taille mémoire en
octets que nécessite le codage en mémoire d’une information.
• Cela devrait être votre deuxième programmeC!
#include <stdio.h>
int main(void)
{
printf("taille char : %ld\n", sizeof(char));
printf("taille short : %ld\n", sizeof(short));
printf("taille int : %ld\n", sizeof(int));
printf("taille long int : %ld\n", sizeof(long int));
printf("taille float : %ld\n", sizeof(float));
printf("taille double : %ld\n", sizeof(double));
return(0);
}

• Entières
• décimale : par exemple, 0 et2437348
• octale : par exemple, entiers 0 et 255 sont respectivement 00 et
0377
• hexadécimale : par exemple, 14 et 255 sont respectivement 0xe
et 0xff
• Réelles
Constante Type
12.34 double
12.3e-4 double
12.34F float
12.34L long double

• Caractères
• Imprimable : 'A' ,'@' ,\\ ,\' ,\? ,\"
• Non imprimable :
char Détails char Détails
\n Nouvelle ligne \r Retour chariot

\t Tabulation \f Saut de page
\b Retour arrière \a Signal d'alert
• Chaînes de caractères
• "Ceci est une chaîne de caractères"
• "ligne 1 \n ligne 2"

• Pour déclarer une variable il faut la
faire précéder de son type
short s1;
• Les déclarations comme n’importe int i;
quelle instruction C doit int j, k, z;
obligatoirement se terminer parun char c;
point-virgule.
float f;
double d1, d2;
• Toutes les déclarations de variables
long double ld;
doivent se faire en début de
programme principal ou en début de
fonction.

L'AFFECTATION
#include <stdio.h>
• La variable située du coté
int main(void) gauche du = représente un
{
int i,j,k; contenant, l’endroit où sera
float d;
char c;
déposée la valeur, alors que
i=3; le côté droit représente la
j=06; //6 en octal: précédé de 0
k=0x6ab; //nombre 6ab en base valeur contenu dans la
//hexadécimale, précédé de 0x variable.
d=1e100;
c='g';
printf("la valeur de i : %d\n", i);

printf("la valeur de j : %d\n", j); • Il est possible aussi
printf("la valeur de k : %d\n", k); d’initialiser une variable au
printf("la valeur de d : %f\n", d);
printf("la valeur de c : %c\n", c); moment de la déclaration :
return (0);
} int i = 3;
• Permet de simplifier certaines affectations
Affectation Affectation composée
a = a + 2; a += 2;
b = b * 3; b *= 3;
c = c / 4; c /= 4;
d = d – 5; d -= 5;

Op Détails Exemples • On distingue en C trois
z = a + b;
catégories d’opérateurs
+ addition
- soustraction z = a - b; • Les opérateurs numérique
* multiplication z = a * b; • Les opérateurs relationnels

/ division z = a / b; • Les opérateurs logiques
% modulo z = a % b;
z++, ++z • Modulo retourne le restede
++ incrémentation
da division de a par b
-- décrémentation z- -, --z
int a = 3, b, c;
b = ++a; /* a et b valent 4 */
c = b++; /* c vaut 4 et b vaut 5 */
• On distingue en C trois
Op Détails Exemples
• Les opérateurs numérique
> supérieur c > d;
>= supérieur ou égal c >= d;
• Les opérateurs relationnels
< inférieur c < d; • Les opérateurs logiques

<= inférieur ou égal c <= d;
== égal c == d; • Les opérateurs relationnels
!= différent c !=d; permettent de comparer en
général deux nombres entreeux
• Le résultat de la comparaison
est soit vraie (résultat 1), soit
faux (résultat 0)

• On distingue en C trois
Op Détails Exemples
! La négation !(3<4)
• Les opérateurs numérique
Retourne faux
• Les opérateurs relationnels
• Les opérateurs logiques
&& Le et logique (c>d) && (c>b)
Vrai seulement si
c>d et c>b • Dans le cas &&, si l’opérande de
gauche est faux, l’opérande de
droite n’est pas évalué.
|| Le ou logique (c>d) ||(c>b)
• Dans le cas ||, l’opérande de
Vrai si c>d ou bien
droite n’est pas évalué si
si c>b l’opérande de gauche estvrai.

Priorités
()
-! Unaires, par ex. -a !a
* /%
+-
< <= > >=
== !=
&& ||
• Dans le cas où les opérateurs ont la même priorité, l’expression

est évaluée de gauche à droite.

• Les instructions sontexécutées.
int a;
a=1;
int b=2;
printf("la valeur de a : %d \n", a);
• Les expressions sont évaluées en un résultat.

a>b
!(a==b)
(a>b) && (a>c)
• Toute expression suivie de « ;» devient une instruction(le

résultat est jeté).
• Le résultat de cette instruction consiste en l’exécution
de bloc instructions1 si la condition est vraie sinon
l’exécution de bloc instructions2 si la condition est
fausse.
if(expression logique){
bloc instruction1
}
else{
bloc instruction2
}
• Le else est facultatif

• Remarques importantes
• Dans le cas ou le bloc d’instruction ne contient qu’une
seule instruction les accolades ne sont pas nécessaires.
if(a>b) {c=b;}
else {c=a};
• L’expression conditionnelle qui suit immédiatement le if

doit obligatoirement être entourée de parenthèses.
if((a>b) && (a>c)) z=a; else z=0;

if(!((a==b) || (c<d))) z=a; else z=0;

if (expression logique 1) {
bloc instruction1 ;
} else if (expression logique 2) {
bloc instruction2 ;
} else {
bloc instruction3 ;
}
• Branchement multiple avec un nombre quelconque de

else if ( ...)
• Le dernier else est toujours facultatif

• C’est l’opérateur qui permet d’afficher des données à l’écran
• il est nécessaire d'inclure l'en-tête standard <stdio.h> au
début du code source du programme
• Format est une chaine de caractères qui contient des codes
de format précédé du symbole %
printf(“format”, liste des valeurs à afficher );
• Il est à notes que la liste d’expression peut être absente pour

peu que le format ne contienne au code format
printf(“bonjour“);

• Le format contient le message à afficher avec des codes de
formats pour les valeurs que l’on veut faire afficher.
• Quelques codes de formats
Type Lettre
Int %d Déjà utilisé dans l'exemple de l'affectation

long %ld
float %f
printf("la valeur de k : %d\n", k);
double %lf
printf("la valeur de d : %f\n", d);
char %c
printf("la valeur de c : %c\n", c);
string %s
short %hd

• C’est l’opérateur qui permet de lire des information au
clavier
• Format come printf est une chaine de caractères qui
contient des codes format précédé du symbole %
scanf(“format”,liste des adresses de variables à lire);
• Les codes de formats sont les même que pour printf

int i1;
float f1;
scanf("%d", &i1);
scanf("%f", &f1);
• L’instruction scanf lit la donnée i1: c’est l’adresse d i1 qui est

passé en paramètre: pour cela la variable est précédée du
symbole &.
• Certains compilateurs n’autorise la lecture que d’une seule

donnée à la fois. Donc cette instruction doit être utilisée avec
précaution.

• Le but des instructions itératives est de pouvoir répéter un
certains nombres d’instructions avec une condition d’arrêt qui
fixe le nombre d’itérations.
• Il existe trois instructions itératives:

• l’instruction do { … } while (condition) ;
• l’instruction while (condition) { …. } ;
• l’instruction for

Initialisation :
compteur=0 ;
Répéter :
Afficher compteur ;
compteur=compteur+1 ;
Tant que :
compteur<10 ;
• L’instruction naturelle pour implémenter cet algorithme

est l’instruction do while :

do
{
…. // bloc d’instructions
} while (condition) ;
• L’instruction sera exécutée au moins une fois.

• Si la condition est vraie, l’instruction de la boucle est ré-
exécutée.
• Si la condition est faux, l’itération se termine et
l’instruction après le do while est exécutée.
• Code C de l'algorithme pour Do While
#include <stdio.h>
int main(void){
Initialisation : int compteur=0;

compteur=0 ;
Répéter :
Afficher compteur ;
do
compteur=compteur+1 ; {
Tant que : printf("%d \n", compteur);
compteur<10 ;
compteur=compteur+1;
} while(compteur<10);
return(0);
}
Initialisation :
compteur=0 ;
Tant que (compteur <10) répéter:

Afficher compteur ;
• L’instruction naturelle pour implémenter cet algorithme

est l’instruction while

while (condition)
{
…. // bloc d’instructions
• Si la condition est vraie, l’instruction de la boucle est

exécutée.
• La condition est évaluée au début de la boucle, donc il
est possible que l’instruction dans la boucle ne soit
jamais exécutée.

• Code C de l'algorithme pour While
#include <stdio.h>
int main (void) {

Initialisation : int compteur=0;
compteur=0 ;
while (compteur<10)
Tant que (compteur <10)
{
répéter:
Afficher compteur ;
printf("%d \n", compteur);
compteur=compteur+1 ; compteur=compteur+1;
}
return (0);
}
Initialisation :
compteur=0 ;
Tant que (compteur <10) répéter:

Afficher compteur ;
• Le même algorithme pour while peut être implémenté

par l'instruction for

for ( expression1 ;expression2 ;expression3) expression1 ;
{ while (expression2)
{
//bloc instructions instructions ;
expression3 ;
} }
• expression1: initialisation avant la 1ère itération.

• exprression2: condition qui est évaluée avant chaque itération.
• expression3: instruction effectuée à la fin de chaque itération
• incrémentation, décrémentation, etc.
• La syntaxe générale de l’instruction for est équivalente avec un
while
• Code C de l'algorithme pour While implémenté par la boucle For
Initialisation :
compteur=0 ;
#include <stdio.h>
Tant que (compteur <10)
répéter: int main(void){
Afficher compteur ;
compteur=compteur+1 ; int compteur ;
for(compteur=0; compteur<10; compteur++)
{
printf("%d \n", compteur);
}
return(0) ;
}
• Si le nombre de boucles est connue à l’avance il est
préférable d’utiliser l’instruction for :
for (i=debut ;i<=fin ;i++)
• Par contre s’il n’est pas possible de connaître le nombre

exact d’itérations on préfèrera alors l’instruction while
ou do while.

• Ecrire un programme qui lit dix nombres au clavier et qui
affiche la somme de ces dix nombres
• Solution : le nombre d’itérations est connu dans cet

exercice donc on utilisera ici une instruction for

#include <stdio.h>
#define Nb_Total 10 //Nb_Total est le nombre de nombres à lire
int main(void)
{
int somme=0;
int nombre_a_lire, i;
for(i=0 ; i< Nb_Total ; i++)

{
printf("Entrer le %d ème nombre \n", i);
scanf("%d", &nombre_a_lire) ;
somme=somme+nombre_a_lire ;
}
printf("La somme des 10 nombres est : %d \n", somme);
return(0);
}

• Ecrire un programme qui détermine si un entier naturel p
strictement supérieur à 2 est un nombre premier
• Solution : un nombre p est premier si aucun nombre n, tel

que 1<n<p, divise p. Dans cet exercice le nombre
d’itération n’est pas connu à l’avance donc on pourra par
exemple utiliser une instructiondo while

▪ #include <stdio.h>
▪ int main(void)
▪ {
▪ int n, p, bool;
▪ printf("Entrer un nombre >2 \n");
▪ scanf("%d", &p) ;
▪ n=2;
bool=1; /* variable drapeau : 1 premier,
0 non premier */
do
{
if(p%n ==0) bool=0;
n=n+1;
} while(n<p) ;
if(bool) printf("%d est premier\n", p);
else printf("%d n’est pas premier\n", p);
}
• L'instruction break peut être employée à l’intérieur de
n'importe quelle boucle.
• Elle permet d'interrompre le déroulement de la boucle, et
passe à la première instruction qui suit la boucle.
• En cas de boucles imbriquées, break fait sortir de la
boucle la plus interne.

#include <stdio.h>
main() { i=0
int i;
for (i = 0; i < 5; i++) i=1
{
i=2
printf("i = %d\n",i);
if (i == 3) i=3
break;
} valeur de i = 3
printf("valeur de i = %d\n",i);
}
• La valeur de i a la sortie de la boucle est 3

#include <stdio.h>
main() { i=0
int i;
for (i = 0; i < 5; i++) i=1
{
i=2
if (i == 3)
continue; i=4
printf("i = %d\n",i);
} valeur de i = 5
printf("valeur de i = %d\n",i);
}
• L'instruction continue permet de passer directement au tour

de boucle suivant, sans exécuter les autres instructions de la
boucle.

Cours

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours

Transféré par

Droits d'auteur :

Formats disponibles

– Types, Operateurs,Conditions, Boucles

Programmation en langage C, ISET’COM 3

Programmation en langage C, ISET’COM 4

Programmation en langage C, ISET’COM 5

Programmation en langage C, ISET’COM 6

nom qu’on appelle identificateur val_5

• Suite de caractères ( lettres, chiffres ou _ ) _total

qui commence par une lettre ou _ _91

• Les lettres accentuées sont à éviter : certains

Programmation en langage C, ISET’COM 7

auto const break continue

Programmation en langage C, ISET’COM 8

Programmation en langage C, ISET’COM 10

Programmation en langage C, ISET’COM 11

Programmation en langage C, ISET’COM 12

char Détails char Détails

\n Nouvelle ligne \r Retour chariot

Programmation en langage C, ISET’COM 13

Programmation en langage C, ISET’COM 14

printf("la valeur de i : %d\n", i);

Affectation Affectation composée

Programmation en langage C, ISET’COM 16

* multiplication z = a * b; • Les opérateurs relationnels

< inférieur c < d; • Les opérateurs logiques

Programmation en langage C, ISET’COM 18

Programmation en langage C, ISET’COM 19

• Dans le cas où les opérateurs ont la même priorité, l’expression

Programmation en langage C, ISET’COM 20

• Les expressions sont évaluées en un résultat.

• Toute expression suivie de « ;» devient une instruction(le

• Le else est facultatif

• L’expression conditionnelle qui suit immédiatement le if

if((a>b) && (a>c)) z=a; else z=0;

Programmation en langage C, ISET’COM 23

• Branchement multiple avec un nombre quelconque de

Programmation en langage C, ISET’COM 24

printf(“format”, liste des valeurs à afficher );

• Il est à notes que la liste d’expression peut être absente pour

Programmation en langage C, ISET’COM 25

Int %d Déjà utilisé dans l'exemple de l'affectation

Programmation en langage C, ISET’COM 26

scanf(“format”,liste des adresses de variables à lire);

• Les codes de formats sont les même que pour printf

Programmation en langage C, ISET’COM 27

• L’instruction scanf lit la donnée i1: c’est l’adresse d i1 qui est

• Certains compilateurs n’autorise la lecture que d’une seule

Programmation en langage C, ISET’COM 28

• Il existe trois instructions itératives:

Programmation en langage C, ISET’COM 29

• L’instruction naturelle pour implémenter cet algorithme

Programmation en langage C, ISET’COM 30

• L’instruction sera exécutée au moins une fois.

Initialisation : int compteur=0;

Tant que (compteur <10) répéter:

• L’instruction naturelle pour implémenter cet algorithme

Programmation en langage C, ISET’COM 33

• Si la condition est vraie, l’instruction de la boucle est

Programmation en langage C, ISET’COM 34

int main (void) {

Tant que (compteur <10) répéter:

• Le même algorithme pour while peut être implémenté

Programmation en langage C, ISET’COM 36

• expression1: initialisation avant la 1ère itération.

• Par contre s’il n’est pas possible de connaître le nombre