Seance 1 - Programmation en langage C

Programmation en langage C
Fahad R. Golra
Faculté des Sciences et Technologies
Université de Lorraine
Séance 1 – Types, Operateurs, Conditions,
Boucles

2 25/09/2017
Historique
Programmation en langage C, Université de Lorraine
Le 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.

3 25/09/2017
Hello World!
• Il faut sauvegarder ce fichier
et lui donner un nom; on
l’appellera ”prem.c” par
exemple.
• Il faut compiler ce programme
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 le monde!
#include <stdio.h>
int main (void) // le fonction main()
{
printf (˝Bonjour tout le monde !˝) ;
return (0) ;
}

4 25/09/2017
Hello World!
• Il faut sauvegarder ce fichier
et lui donner un nom; on
l’appellera ”prem.c” par
exemple.
• Il faut compiler ce programme
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 le monde!
#include <stdio.h>
{
return (0) ;
}
Importation des bibliothèques
Corps du programme

• 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 de ponctuation
5 25/09/2017
Les composants élémentaires du C

6 25/09/2017
Les commentaires
• Le compilateur ignore les
commentaires
• Deux sorts de commentaires
• Multi-lignes
• Un seul ligne
• Il n’est pas possible d’imbriquer
des commentaires
/*ceci /* est un commentaire */ */
/* Voici mon premier programme C que
j’ai écrit le vendredi 8 septembre
2017 */
#include <stdio.h>
{
return (0) ;
}

• Dans un programme C les variables, les
fonctions, les types etc. sont désignés par un
nom qu’on appelle identificateur
• Suite de caractères ( lettres, chiffres ou _ )
qui commence par une lettre ou _
• Les lettres accentuées sont à éviter : certains
compilateurs les acceptent d’autres non
• Attention, le C fait la différence entre
minuscule et majuscule :
Ligne_lig ≠ ligne_lig
7 25/09/2017
Les identificateurs
Ligne_lig
val_5
_total
_91

• Les mots réservés par la langage
• Langage C a 32 mots-clés
• Ils ne peuvent pas être utilisés comme identificateurs
8 25/09/2017
Les mots-clefs
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é
• Un type définit un ensemble
de valeurs et d'opérations qui
peuvent être effectuées sur
celui-ci
• Le type int peut représenter
les nombres entiers compris
entre: -2147483648 et
+2147483647
• Un type spécial appelé void
explique qu'aucun type ne
peut décrire les données
9 25/09/2017
Les types de base
Types Valeurs Octets
• char
• int
• short
• long int
• float
• double
• void
Un caractère
Nombres entiers
Nombres entiers
Nombres entiers
Nombres réelles
Nombres réelles
Pas de type
1
4
2
8
4
8
0

• 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 −231 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).
10 25/09/2017
Les types de base

• 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 programme C!
11 25/09/2017
L'opérateur sizeof
#include <stdio.h>
int main(void)
{
printf("taille char : %ldn", sizeof(char));
printf("taille short : %ldn", sizeof(short));
printf("taille int : %ldn", sizeof(int));
printf("taille long int : %ldn", sizeof(long int));
printf("taille float : %ldn", sizeof(float));
printf("taille double : %ldn", sizeof(double));
return(0);
}

• Entières
• décimale : par exemple, 0 et 2437348
• 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
12 25/09/2017
Les constantes
Constante Type
12.34
12.3e-4
12.34F
12.34L
double
double
float
long double

• Caractères
• Imprimable : 'A' , '@' , , ' , ? , "
• Non imprimable :
• Chaînes de caractères
• "Ceci est une chaîne de caractères"
• "ligne 1 n ligne 2"
13 25/09/2017
Les constantes
char Détails char Détails
n
t
b
Nouvelle ligne
Tabulation
Retour arrière
r
f
a
Retour chariot
Saut de page
Signal d'alert

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

• La variable située du coté
gauche du = représente un
contenant, l’endroit où sera
déposée la valeur, alors que
le côté droit représente la
valeur contenu dans la
variable.
• Il est possible aussi
d’initialiser une variable au
moment de la déclaration :
int i = 3;
15 25/09/2017
L'affectation
#include <stdio.h>
int main(void)
{
int i,j,k;
float d;
char c;
i=3;
j=06; //6 en octal: précédé de 0
k=0x6ab; //nombre 6ab en base
//hexadécimale, précédé de 0x
d=1e100;
c='g';
printf("la valeur de i : %dn", i);
printf("la valeur de j : %dn", j);
printf("la valeur de k : %dn", k);
printf("la valeur de d : %fn", d);
printf("la valeur de c : %cn", c);
return (0);
}

• Permet de simplifier certaines affectations
16 25/09/2017
L'affectation composée
Affectation Affectation composée
a = a + 2;
b = b * 3;
c = c / 4;
d = d – 5;
a += 2;
b *= 3;
c /= 4;
d -= 5;

• On distingue en C trois
catégories d’opérateurs
• Les opérateurs numérique
• Les opérateurs relationnels
• Les opérateurs logiques
• Modulo retourne le reste de
da division de a par b
17 25/09/2017
Les opérateurs
Op Détails Exemples
+
-
*
/
%
++
- -
addition
soustraction
multiplication
division
modulo
incrémentation
décrémentation
z = a + b;
z = a - b;
z = a * b;
z = a / b;
z = a % b;
z++, ++z
z- -, - -z
int a = 3, b, c;
b = ++a; /* a et b valent 4 */
c = b++; /* c vaut 4 et b vaut 5 */

permettent de comparer en
général deux nombres entre eux
• Le résultat de la comparaison
est soit vraie (résultat 1), soit
faux (résultat 0)
18 25/09/2017
Les opérateurs
>
>=
<
<=
==
!=
supérieur
supérieur ou égal
inférieur
inférieur ou égal
égal
différent
c > d;
c >= d;
c < d;
c <= d;
c == d;
c !=d;

• Dans le cas &&, si l’opérande de
gauche est faux, l’opérande de
droite n’est pas évalué.
• Dans le cas ||, l’opérande de
droite n’est pas évalué si
l’opérande de gauche est vrai.
19 25/09/2017
Les opérateurs
!
&&
||
La négation
Le et logique
Le ou logique
!(3<4)
Retourne faux
(c>d) && (c>b)
Vrai seulement si
c>d et c>b
(c>d) || (c>b)
Vrai si c>d ou bien
si c>b

• Dans le cas où les opérateurs ont la même priorité, l’expression
est évaluée de gauche à droite.
20 25/09/2017
Priorités des opérateurs
Priorités
( )
- ! Unaires, par ex. -a !a
* / %
+ -
< <= > >=
== !=
&& ||

• Les instructions sont exécutées.
• Les expressions sont évaluées en un résultat.
• Toute expression suivie de « ; » devient une instruction (le
résultat est jeté).
21 25/09/2017
Expressions et instructions
int a;
a=1;
int b=2;
printf("la valeur de a : %d n", a);
a>b
!(a==b)
(a>b) && (a>c)

• 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.
• Le else est facultatif
22 25/09/2017
Les instructions conditionnel
if(expression logique){
bloc instruction1
}
else{
bloc instruction2
}

• Remarques importantes
• Dans le cas ou le bloc d’instruction ne contient qu’une
seule instruction les accolades ne sont pas nécessaires.
• L’expression conditionnelle qui suit immédiatement le if
doit obligatoirement être entourée de parenthèses.
23 25/09/2017
if(a>b) {c=b;}
else {c=a};
if((a>b) && (a>c)) z=a; else z=0;
if(!((a==b) || (c<d))) z=a; else z=0;

• Branchement multiple avec un nombre quelconque de
else if ( ... )
• Le dernier else est toujours facultatif
24 25/09/2017
if (expression logique 1) {
bloc instruction1 ;
} else if (expression logique 2) {
bloc instruction2 ;
} else {
bloc instruction3 ;
}

• 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 %
• Il est à notes que la liste d’expression peut être absente pour
peu que le format ne contienne au code format
25 25/09/2017
La fonction d’écriture printf
printf(“format”, liste des valeurs à afficher );
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
26 25/09/2017
La fonction d’écriture printf
Type Lettre
Int
long
float
double
char
string
short
%d
%ld
%f
%lf
%c
%s
%hd
Déjà utilisé dans l'exemple de l'affectation
printf("la valeur de k : %dn", k);
printf("la valeur de d : %fn", d);
printf("la valeur de c : %cn", c);

• 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 %
• Les codes de formats sont les même que pour printf
27 25/09/2017
La fonction de saisie scanf
scanf(“format”,liste des adresses de variables à lire);

• 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.
28 25/09/2017
La fonction de saisie scanf
int i1;
float f1;
scanf("%d", &i1);
scanf("%f", &f1);

• 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
29 25/09/2017
Les instructions Itératives

• L’instruction naturelle pour implémenter cet algorithme
est l’instruction do while :
30 25/09/2017
L'instruction Do While
Initialisation :
compteur=0 ;
Répéter :
Afficher compteur ;
compteur=compteur+1 ;
Tant que :
compteur<10 ;

• 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.
31 25/09/2017
do
{
…. // bloc d’instructions
} while (condition) ;

32 25/09/2017
• Code C de l'algorithme pour Do While
#include <stdio.h>
int main(void){
int compteur=0;
do
{
printf("%d n", compteur);
compteur=compteur+1;
} while(compteur<10);
return(0);
}
Initialisation :
compteur=0 ;
Répéter :
Afficher compteur ;
Tant que :
compteur<10 ;

• L’instruction naturelle pour implémenter cet algorithme
est l’instruction while
33 25/09/2017
L'instruction While
Initialisation :
compteur=0 ;
Tant que (compteur <10) répéter:
Afficher compteur ;

• 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.
34 25/09/2017
L'instruction While
while (condition)
{
…. // bloc d’instructions
}

35 25/09/2017
L'instruction While
#include <stdio.h>
int main (void) {
int compteur=0;
while (compteur<10)
{
compteur=compteur+1;
}
return (0);
}
• Code C de l'algorithme pour While
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
36 25/09/2017
L'instruction For
Initialisation :
compteur=0 ;
Tant que (compteur <10) répéter:
Afficher compteur ;

• 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
37 25/09/2017
L'instruction For
expression1 ;
while (expression2)
{
instructions ;
expression3 ;
}
for ( expression1 ; expression2 ; expression3)
{
//bloc instructions
}

38 25/09/2017
L'instruction For
• Code C de l'algorithme pour While implémenté par la boucle For
Initialisation :
compteur=0 ;
Tant que (compteur <10)
répéter:
Afficher compteur ;
#include <stdio.h>
int main(void){
int compteur ;
for(compteur=0; compteur<10; 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.
39 25/09/2017
Les instructions Itératives

• 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
40 25/09/2017
Exercice 1 : Les instructions Itératives

41 25/09/2017
#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 instruction do while
42 25/09/2017

43 25/09/2017
#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 premiern", p);
else printf("%d n’est pas premiern", 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.
44 25/09/2017
L'instruction break

• La valeur de i a la sortie de la boucle est 3
45 25/09/2017
L'instruction break
#include <stdio.h>
main() {
int i;
for (i = 0; i < 5; i++)
{
printf("i = %dn",i);
if (i == 3)
break;
}
printf("valeur de i = %dn",i);
}
i=0
i=1
i=2
i=3
valeur de i = 3

• L'instruction continue permet de passer directement au tour
de boucle suivant, sans exécuter les autres instructions de la
boucle.
46 25/09/2017
L'instruction continue
#include <stdio.h>
main() {
int i;
for (i = 0; i < 5; i++)
{
if (i == 3)
continue;
printf("i = %dn",i);
}
printf("valeur de i = %dn",i);
}
i=0
i=1
i=2
i=4
valeur de i = 5

Seance 1 - Programmation en langage C

Contenu connexe

Tendances

Similaire à Seance 1 - Programmation en langage C

Plus de Fahad Golra

Dernier

Seance 1 - Programmation en langage C