progII 0

Programmation II
Module: M1 - LFSMI - S4
Prof. R. HANNANE
r.hannane@uca.ma
Faculté des Sciences Semlalia, Marrakech

Université Cadi Ayyad
Prof. R. HANNANE (FSSM) Programmation II 1 / 52

Les bases de la programmation en C
Les bases de la
programmation en C:
Rappel

Introduction
Le C a été conçu en 1972 par Dennis Richie et Ken Thompson,

chercheurs aux Bell Labs, afin de développer un système
d’exploitation UNIX
Depuis cette date, le langage C a continué d’évoluer, à travers

les nombreuses versions de compilateurs qui ont vu le jour
En 1983, l’ANSI (American National Standards Institute) décida

de normaliser le langage
⇒ Ce travail s’acheva en 1989 par la définition de la norme
ANSI C

Environnements de programmation en C
Le langage C est un langage compilé, ce qui signifie qu’un
programme écrit en C doit subir une suite de traitements
pour que la machine puisse l’exécuter.
Conseil:
Vous avez besoin d’un compilateur ANSI-C
Exemple: Turbo C, Borland C, Microsoft C, intel C, gcc cc, Zortech

C, Symantec,...
Remarque:
Les système d’exploitation de type UNIX disposent de compilateurs C
immédiatement disponible. ⇒ Il s’agit de gcc et cc.

Environnements de programmation en C
On utilise de préférence le compilateur gcc du projet GNU

⇒Ce compilateur est livré gratuitement avec sa documentation
et ses sources.
Par défaut, gcc active toutes les étapes de la compilation
On le lance par la commande:

gcc [ options ] fichier . c [ - llibrairies ]

Le fichier source
Pour créer un fichier source il faut utiliser un éditeur de texte, puis
taper le programme en respectant la syntaxe du langage C et
enregistrer le fichier ainsi créé en indiquant son nom.
Le fichier source d’un programme écrit en langage C est un simple
fichier texte dont l’extension est par convention " .c " (exemple
test.c).
Attention:
L’extension doit être en minuscule.
Remarque:
Ce fichier source doit être un fichier texte non formaté, c’est-à-dire un fichier
texte dans sa plus simple expression, sans mise en forme particulière ou caractères
spéciaux, il contient uniquement les caractères ASCII de base.
L’ensemble du texte doit respecter la syntaxe du langage C.

Premier programme en C
Un programme exécutable écrit en langage C, comporte
obligatoirement une fonction principale appelée main()
Cette fonction principale renferme les instructions qui doivent
être exécutées.
Ces instructions sont comprises entre les accolades ouvrante et
fermante qui suivent le nom de la fonction.
Voici un exemple de programme en C, il s’agit du texte contenu dans un
fichier nommé ”test.c” et on le voit tel qu’il apparaı̂t dans l’éditeur de
texte. Ce texte respecte la syntaxe du C.
Exemple 1:
# include < stdio .h >
void main ()
{
printf ( " Ceci est votre premier programme \ n " );
}

Premier programme en C
Le type retourné par la fonction main() est void, c’est-à-dire ” rien ”.
La norme actuelle du C impose que le type retourné par la
fonction soit explicitement annoncé, on ne peut donc pas écrire
"main() " sans spécifier le type de retour de cette fonction.
La fonction printf() produit une émission de caractères en séquence
vers la sortie standard nommée stdout (par défaut il s’agit de l’écran).
Il faut inclure un fichier nommé ”stdio.h” qui définit l’usage de cette
fonction printf.
Entre une paire de " (double quote) il y a une chaı̂ne de caractères
constante. ⇒ On parle de littéral constant de type chaı̂ne de caractères.
De fait, ”Ceci est votre premier programme \n” est donc une chaı̂ne de
caractères qui va s’afficher telle quelle.
Il s’agit du paramètre réel ( au sens effectivement transmis) de la
fonction printf. La séquence des deux caractères \ et n sera interprétée
par la fonction printf comme l’affichage d’un saut de ligne
Les composants élémentaires du C
Un programme en langage C est constitué des six groupes de

composants élémentaires suivants :
1 Les identificateurs
2 Les mots-clefs
3 Les constantes
4 Les chaı̂nes de caractères
5 Les opérateurs
6 Les signes de ponctuation
On peut ajouter à ces six groupes les commentaires, qui sont

enlevés par le préprocesseur.


Les identificateurs
Le rôle d’un identificateur est de donner un nom à une

entité du programme.
Plus précisément, un identificateur peut désigner :

I un nom de variable ou de fonction,
I un type défini par typedef, struct, union ou enum,
I une étiquette
Un identificateur est une suite de caractères parmi :

les lettres (minuscules ou majuscules, mais non accentuées),
les chiffres,
le “blanc souligné” ( )

Les identificateurs
Attention:
Le premier caractère d’un identificateur ne peut pas être un
chiffre.
Par exemple: var 1, tab 23 ou deb sont des identificateurs valides;
par contre, 1i et i:j ne le sont pas.
Il est cependant déconseillé d’utiliser comme premier
caractère d’un identificateur car il est souvent employé pour
définir les variables globales de l’environnement C.
Les majuscules et minuscules sont différenciées.
Le compilateur peut tronquer les identificateurs au-delà d’une
certaine longueur. Cette limite dépend des implémentations, mais
elle est toujours supérieure à 31 caractères.


Les mots-clefs
Un certain nombre de mots, appelés mots-clefs, sont réservés pour le

langage lui-même et ne peuvent pas être utilisés comme identificateurs.
L’ANSI C compte 32 mots-clefs que l’on peut ranger en

catégories:
I Les spécificateurs de stockage: auto, register, static,
extern, typedef
I Les spécificateurs de type: char, double, enum, float, int,
union, unsigned, void
I Les qualificateurs de type: const, volatile
I Les instructions de contrôle: break, case, continue, default,
switch, while
I Divers: return, sizeof


Les commentaires
Un commentaire est une portion de texte dans le fichier source qui a pour but
d’expliquer le fonctionnement du programme sans que le compilateur ne les
prenne en compte
Deux types de balises possibles:

1 //: mets en commentaire tout ce qui suit sur la ligne
2 /* */: met en commentaire tout ce qui suit dans le fichier jusqu’à la balise fermante
(débute par /* et se termine par */)
Exemple 2:
/* Ceci est un commentaire
de plusier lignes
*/
// Ceci est un commentaire sur une seule ligne
Attention:
On ne peut pas imbriquer des commentaires
⇒ Quand on met en commentaire un morceau de programme, il faut donc veiller à ce que
celui-ci ne contienne pas de commentaire


Expression & Instruction
Une expression est une suite de composants élémentaires syntaxiquement

correcte
Exemple 3:
x =0
/* ou bien */
( i >= 0) && ( i < 10) && ( p != 0)
Une instruction est une expression suivie d’un point-virgule. ⇒ Le

point-virgule signifie en quelque sorte “évaluer cette expression”.
Plusieurs instructions peuvent être rassemblées par des accolades { et }

pour former une instruction composée ou bloc qui est syntaxiquement
équivalent à une instruction.
Exemple 4:
if ( x != 0){
z = y / x;
t = y % x;
}


Expression & Instruction
Une instruction composée d’un spécificateur de type et

d’une liste d’identificateurs séparés par une virgule est
une déclaration
Exemple 5:
int a ;
int b = 1 , c ;
double x = 2.38 e4 ;
char message [80];
En C, toute variable doit faire l’objet d’une déclaration

avant d’être utilisée.

Les types prédéfinis

Le C est un langage typé ⇒ Cela signifie que toute
variable, constante ou fonction est d’un type précis.
Le type d’un objet définit la façon dont il est représenté
en mémoire:
I La mémoire de l’ordinateur se décompose en une suite continue
d’octets.
I Chaque octet de la mémoire est caractérisé par son adresse, qui
est un entier.
I Deux octets contigus en mémoire ont des adresses qui diffèrent
d’une unité.
Quand une variable est définie, il lui est attribué une

adresse. Cette variable correspondra à une zone mémoire dont
la longueur (le nombre d’octets) est fixée par le type.
La taille mémoire correspondant aux différents types

dépend des compilateurs ; toutefois, la norme ANSI spécifie
un certain nombre de contraintes.
Les types de base en C concernent les caractères, les entiers et

les flottants (nombres réels).
Ils sont désignés par les mots-clefs suivants :

Exemple 6:
char
int
float double
short long unsigned


Le type caractère
Le mot-clef char désigne un objet de type caractère.
Un char peut contenir n’importe quel élément du jeu de

caractères de la machine utilisée.
La plupart du temps, un objet de ce type est codé sur un

octet ⇒ c’est l’objet le plus élémentaire en C.
Une des particularités de ce type en C est qu’il peut être

assimilé à un entier: ⇒ tout objet de type char peut être
utilisé dans une expression qui utilise des objets de type entier.


Le type caractère
Par exemple, si c est de type char, l’expression c + 1 est valide.

⇒Elle désigne le caractère suivant dans le code ASCII.
Le programme suivant imprime le caractère ’B’:

Exemple 7:
void main () {
char c = ’A ’;
printf ( " % c " , c +1);
}
Attention:
Suivant les implémentations, le type char est signé ou non.
En cas de doute, il vaut mieux préciser unsigned char ou
signed char.

Le type entiers
Le mot-clef désignant le type entier est int.
Il peut être précédé d’un attribut de précision (short ou long)

et/ou d’un attribut de représentation (unsigned).
Un objet de type short int a au moins la taille d’un char et au

plus la taille d’un int.
En général, un short int est codé sur 16 bits.
Un objet de type long int a au moins la taille d’un int


Le type entiers
Le bit de poids fort d’un entier est son signe:

I Un entier positif est donc représenté en mémoire par la
suite de 32 bits dont le bit de poids fort vaut 0 et les 31
autres bits correspondent à la décomposition de l’entier en
base 2.
I Un entier négatif est, lui, représenté par une suite de 32
bits dont le bit de poids fort vaut 1 et les 31 autres bits
correspondent à la valeur absolue de l’entier représentée
suivant la technique dite “complément à 2”
L’attribut unsigned spécifie que l’entier n’a pas de signe.
Plus généralement, les valeurs maximales et minimales des
différents types entiers sont définies dans la librairie
standard limits.h

Le type flottants
Les types float, double et long double servent à représenter

des nombres en virgule flottante ⇒ c’est-à-dire des nombres
dans lesquels la position de la virgule n’est pas fixe.
Une partie des bits d’un réel sert à coder l’exposant, le

reste des bits permettent de coder le nombre sans
virgule, la mantisse
Le float correspond à une simple précision, le double à une

double précision.
Un float correspond à un réceptacle de 4 octets. Le

réceptacle est de 8 octets pour un double


Les constantes
Une constante est une valeur qui apparaı̂t littéralement

dans le code source d’un programme
Le type de la constante étant déterminé par la façon dont

la constante est écrite.
Les constantes peuvent être de 4 types: entier, flottant

(nombre réel), caractère, énumération.
Ces constantes vont être utilisées, par exemple,

pour initialiser une variable.

Les opérateurs
L’affectation
En C, l’affectation est un opérateur à part entière.
Elle est symbolisée par le signe =.
Sa syntaxe est la suivante :

variable = expression
Le terme de gauche de l’affectation peut être une variable

simple, un élément de tableau mais pas une constante.
Cette expression a pour effet d’évaluer expression et

d’affecter la valeur obtenue à variable.

Les opérateurs
L’affectation
L’affectation effectue une conversion de type implicite :

la valeur de l’expression (terme de droite) est convertie
dans le type du terme de gauche.
Exemple 8:
void main () {
int i , j = 2;
float x = 2.5;
i = j + x;
x = x + i;
printf ( " \ n % f \ n " ,x );
/* x vaut la valeur 6.5 ( et non 7) , car dans
l ’ instruction " i = j + x ;" , l ’ expression j + x a é t é convertie
en entier */
}

Les opérateurs
Les opérateurs arithmétiques
Les opérateurs arithmétiques classiques sont:

I L’opérateur unaire: ”-” (changement de signe)
I Les opérateurs binaires: + addition, - soustraction,
* multiplication, / division, % reste de la division (modulo)
Ces opérateurs agissent de la façon attendue sur les entiers
comme sur les flottants.
Leurs seules spécificités sont les suivantes :
1. Contrairement à d’autres langages, le C ne dispose que de la
notation / pour désigner à la fois la division entière et la
division entre flottants. ⇒ Si les deux opérandes sont de type
entier, l’opérateur / produira une division entière (quotient de la
division). Par contre, il délivrera une valeur flottante dès que
l’un des opérandes est un flottant.
Les opérateurs
Les opérateurs arithmétiques
Exemple 9:
float x ;
x = 3 / 2; /* affecte à x la valeur 1. */
/** ************* Par contre * * * * * * * * * * * * * * * * * * * * * * * * * */
x = 3 / 2.; /* affecte à x la valeur 1.5 */
2. L’opérateur % ne s’applique qu’à des opérandes de type

entier. Si l’un des deux opérandes est négatif, le signe du reste
dépend de l’implémentation, mais il est en général le même que
celui du dividende.
Remarque:
Notons qu’il n’y a pas en C d’opérateur effectuant
l’élévation à la puissance. De façon générale, il faut
utiliser la fonction pow(x,y) de la librairie math.h pour
calculer x y
Les opérateurs
Les opérateurs relationnels
Les opérateurs relationnels sont:

• > strictement supérieur
• >= supérieur ou égal
• < strictement inférieur
• <= inférieur ou égal
• == égal
• ! = différent
Leur syntaxe est:

expression1 op expression2
Remarque:
Les deux expressions sont évaluées puis comparées.
La valeur rendue est de type int (il n’y a pas de type booléen en C); elle vaut 1
si la condition est vraie, et 0 sinon.

Les opérateurs
Les opérateurs relationnels
Attention:
Attention à ne pas confondre l’opérateur de test d’égalité
== avec l’opérateur d’affection =
Exemple 10:
void main () {
int a = 0;
int b = 1;
if ( a = b )
printf ( " \ n a et b sont egaux !\ n " );
else
printf ( " \ n a et b sont differents \ n " );
}
/* affiche à l ’é cran :
a et b sont egaux ! */

Les opérateurs
Les opérateurs logiques booléens
Les opérateurs logiques booléens sont:

• && : Et logique
• k : Ou logique
• ! : Négation logique
Comme pour les opérateurs de comparaison, la valeur

retournée par ces opérateurs est un int qui vaut 1 si la
condition est vraie et 0 sinon.
Dans une expression de type

expression1 op1 expression2 op2 ... expressionN
l’évaluation se fait de gauche à droite et s’arrête dès que

le résultat final est déterminé.
Les opérateurs
Les opérateurs logiques booléens
Exemple:
Exemple 11:
int i ;
int p =0;
if (( i >= 0) && ( i <= 9) && !( p == 0))
...
/* ici , la derni è re clause ne sera pas é valu é e
si i n ’ est pas entre 0 et 9. */

Les opérateurs
Les opérateurs logiques bit à bit
Les six opérateurs suivants permettent de manipuler des

entiers au niveau du bit:
& et, | ou inclusif, ∧ ou exclusif , ∼ complément à 1 ,
<< décalage à gauche, >> décalage à droite
Ces opérateurs s’appliquent aux entiers de toute longueur
(short, int ou long), signés ou non.
En pratique, les opérateurs &, | et ∼ consistent à appliquer bit à
bit les opérations suivantes:
L’opérateur unaire ∼ change la valeur de chaque bit d’un

entier.
Les opérateurs
Les opérateurs logiques bit à bit
Considérons par exemple les entiers a = 77 et b = 23 de type
unsigned char (i.e. 8 bits).
⇒ En base 2 il s’écrivent respectivement 01001101 et 00010111.

Les opérateurs
Les opérateurs d’affectation composée
Les opérateurs d’affectation composée sont:

• += −= ∗= /= %= &=
∧ = |= <<= >>=
Pour tout opérateur op, l’expression

expression1 op = expression2
est équivalente à
expression1 = expression1 op expression2
Avec l’affection composée, expression1 n’est évaluée qu’une

seule fois

Les opérateurs
Les opérateurs d’incrémentation et de décrémentation
Les opérateurs d’incrémentation ++ et de

décrémentation −− s’utilisent aussi bien en suffixe (i + +)
qu’en préfixe (+ + i)
Dans les deux cas la variable i sera incrémentée, toutefois dans

la notation suffixe la valeur retournée sera l’ancienne valeur de i
alors que dans la notation préfixe se sera la nouvelle
Exemple 12:
int a = 3 , b , c ;
b = ++ a ; /* a et b valent 4 */
c = b ++; /* c vaut 4 et b vaut 5 */

Les opérateurs
L’opérateur virgule
Une expression peut être constituée d’une suite

d’expressions séparées par des virgules :
expression1 , expression2 , ... , expressionN
Cette expression est alors évaluée de gauche à droite.

⇒ Sa valeur sera la valeur de l’expression de droite.
Exemple 13:
void main () {
int a , b ;
b = (( a = 3) , ( a + 2));
printf ( " \ n b = % d \ n " ,b );
// imprime b = 5.
}

Les opérateurs
L’opérateur conditionnel ternaire
L’opérateur conditionnel ? est un opérateur ternaire.
Sa syntaxe est la suivante :

condition ? expression1 : expression2
⇒ Cette expression est égale à expression1 si condition est

satisfaite, et à expression2 sinon.
Exemple 14:
x >= 0 ? x : -x // correspond à
la valeur absolue d ’ un nombre
m = (( a > b ) ? a : b ); // affecte à
m le maximum de a et de b

Les opérateurs
L’opérateur de conversion de type
L’opérateur de conversion de type, appelé cast, permet

de modifier explicitement le type d’un objet.
On écrit:
( type ) objet
Exemple 15:
void main () {
int i = 3 , j = 2;
printf ( " % f \ n " ,( float ) i / j );
}
// retourne la valeur 1.5

Les opérateurs
Règles de priorité des opérateurs
Le tableau suivant classe les opérateurs par ordres de
priorité décroissants

Les opérateurs
Règles de priorité des opérateurs
Remarque sur le tableau de priorité des opérateurs:

Les opérateurs placés sur une même ligne ont
même priorité.
Si dans une expression figurent plusieurs opérateurs de

même priorité, l’ordre d’évaluation est définie par la
flèche de la seconde colonne du tableau.
On préferera toutefois mettre des parenthèses en cas de

doute

Les instruction de contrôle
On appelle instruction de contrôle toute instruction qui

permet de contrôler le fonctionnement d’un programme.
Parmi les instructions de contrôle, on distingue:
1) Les instructions de branchement
2) Les boucles


1) Les instructions de branchement conditionnel: Branchement conditionnel
if---else
La forme la plus générale est :
if ( expression1 )
instruction1
else if ( expression2 )
instruction2
...
else if ( expressionN )
instructionN
else
instructionK
avec un nombre quelconque de else if (...).
Le dernier else est toujours facultatif.
La forme la plus simple est:
if ( expression )
instruction
Chaque instruction peut être un bloc d’instructions


1) Les instructions de branchement conditionnel: Branchement multiple switch
Sa forme la plus générale est:
switch ( expression )
{
case constante1 :
liste instructions 1
break ;
case constante2 :
liste instructions 2
break ;
...
case constanteN :
liste instructions n
break ;
default :
liste instructions k
break ;
}
Si la valeur de expression est égale à l’une des constantes, la liste d’instructions

correspondant est exécutée. Sinon la liste d’instructions k correspondant à
default est exécutée.
L’instruction default est facultative.


2) Les boucles
Les boucles permettent de répéter une série d’instructions

tant qu’une certaine condition n’est pas vérifiée.
On distingue:
• Boucle while
• Boucle do---while
• Boucle for


2) Les boucles: Boucle while
La syntaxe de while est la suivante:
while ( expression )
instruction
Tant que expression est vérifiée (i.e., non nulle), instruction est
exécutée.
Si expression est nulle au départ, instruction ne sera jamais
exécutée.
instruction peut évidemment être une instruction composée.
Exemple 16:
i = 1;
while ( i < 10) {
printf ( " \ n i = % d " ,i );
i ++;
} // ce programme affiche les entiers de 1 à 9

2) Les boucles: Boucle do---while
Il peut arriver que l’on ne veuille effectuer le test de continuation
qu’après avoir exécuté l’instruction.⇒ Dans ce cas, on utilise la boucle
do---while.
Sa syntaxe est :
do
instruction
while ( expression );
Ici, instruction sera exécutée tant que expression est non nulle. ⇒Cela signifie
que instruction est toujours exécutée au moins une fois
Exemple 17:
// programme pour saisir au clavier un entier entre 1 et 10 :
int a ;
do
{
printf ( " \ n Entrez un entier entre 1 et 10 : " );
scanf ( " % d " ,& a );
}
while (( a <= 0) || ( a > 10));


2) Les boucles: Boucle for
La syntaxe de for est :

for ( expr1 ; expr2 ; expr3 )
instruction
Une version équivalente plus intuitive est :

expr1 ;
while ( expr2 )
{
instruction expr3 ;
}
Exemple 18:
// pour imprimer tous les entiers de 0 à 9 , on é crit :
for ( i = 0; i < 10; i ++)
printf ( " \ n i = % d " ,i );
// a la fin de cette boucle , i vaudra 10
Les trois expressions utilisées dans une boucle for peuvent être
constituées de plusieurs expressions séparées par des virgules. Cela
permet par exemple de faire plusieurs initialisations à la fois.
Les instructions de branchement non conditionnel

Branchement non conditionnel break
L’instruction break peut être employée à l’intérieur de n’importe quelle boucle.

Elle permet d’interrompre le déroulement de la boucle, et passe à la première
instruction qui suit la boucle.
En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.
Exemple 19:
void main () {
int i ;
for ( i = 0; i < 5; i ++)
{
printf ( " i = % d \ n " ,i );
if ( i == 3)
break ;
}
printf ( " valeur de i a la sortie de la boucle = % d \ n " ,i );
}
/* affiche à l ’é cran :
i =0
i =1
i =2
i =3
valeur de i a la sortie de la boucle = 3 */


Branchement non conditionnel continue
L’instruction continue permet de passer directement au tour de

boucle suivant, sans exécuter les autres instructions de la boucle
Exemple 20:
void main ()
{
int i ;
for ( i = 0; i < 5; i ++)
{
if ( i == 3)
continue ;
printf ( " i = % d \ n " ,i );
}
printf ( " valeur de i a la sortie de la boucle = % d \ n " ,i );
}
/* Affiche :
i =0
i =1
i =2
i =4
valeur de i a la sortie de la boucle = 5 */


Branchement non conditionnel goto
L’instruction goto permet d’effectuer un saut jusqu’à

l’instruction etiquette correspondant.

Les conventions d’écriture d’un programme C
On n’écrit qu’une seule instruction par ligne : le point

virgule d’une instruction ou d’une déclaration est toujours
le dernier caractère de la ligne.
Les instructions sont disposées de telle façon que la

structure modulaire du programme soit mise en évidence.
En particulier, une accolade ouvrante marquant le début d’un
bloc doit être seule sur sa ligne ou placée à la fin d’une ligne.
Une accolade fermante est toujours seule sur sa ligne.

Les conventions d’écriture d’un programme C
On laisse un blanc:
I entre les mots-clefs if, while, do, switch et la
parenthèse ouvrante qui suit
I après une virgule,
I de part et d’autre d’un opérateur binaire.
On ne met pas de blanc entre un opérateur unaire et son

opérande, ni entre les deux caractères d’un opérateur
d’affectation composée.
Les instructions doivent être indentées afin que toutes les

instructions d’un même bloc soient alignées

progII 0

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

progII 0

Transféré par

Droits d'auteur :

Formats disponibles

Programmation II

Faculté des Sciences Semlalia, Marrakech

Prof. R. HANNANE (FSSM) Programmation II 1 / 52

Prof. R. HANNANE (FSSM) Programmation II 2 / 52

Le C a été conçu en 1972 par Dennis Richie et Ken Thompson,

Depuis cette date, le langage C a continué d’évoluer, à travers

En 1983, l’ANSI (American National Standards Institute) décida

Prof. R. HANNANE (FSSM) Programmation II 3 / 52

Exemple: Turbo C, Borland C, Microsoft C, intel C, gcc cc, Zortech

Prof. R. HANNANE (FSSM) Programmation II 4 / 52

On utilise de préférence le compilateur gcc du projet GNU

Par défaut, gcc active toutes les étapes de la compilation

On le lance par la commande:

Prof. R. HANNANE (FSSM) Programmation II 5 / 52

L’ensemble du texte doit respecter la syntaxe du langage C.

Prof. R. HANNANE (FSSM) Programmation II 6 / 52

Prof. R. HANNANE (FSSM) Programmation II 7 / 52

Les composants élémentaires du C

Un programme en langage C est constitué des six groupes de

On peut ajouter à ces six groupes les commentaires, qui sont

Prof. R. HANNANE (FSSM) Programmation II 9 / 52

Les composants élémentaires du C

Le rôle d’un identificateur est de donner un nom à une

Plus précisément, un identificateur peut désigner :

Un identificateur est une suite de caractères parmi :

Les composants élémentaires du C

Prof. R. HANNANE (FSSM) Programmation II 11 / 52

Les composants élémentaires du C

Un certain nombre de mots, appelés mots-clefs, sont réservés pour le

L’ANSI C compte 32 mots-clefs que l’on peut ranger en

Prof. R. HANNANE (FSSM) Programmation II 12 / 52

Les composants élémentaires du C

Deux types de balises possibles:

Prof. R. HANNANE (FSSM) Programmation II 13 / 52

Les composants élémentaires du C

Une expression est une suite de composants élémentaires syntaxiquement

Une instruction est une expression suivie d’un point-virgule. ⇒ Le

Plusieurs instructions peuvent être rassemblées par des accolades { et }

Prof. R. HANNANE (FSSM) Programmation II 14 / 52

Les composants élémentaires du C

Une instruction composée d’un spécificateur de type et

En C, toute variable doit faire l’objet d’une déclaration

Prof. R. HANNANE (FSSM) Programmation II 15 / 52

Les types prédéfinis

Quand une variable est définie, il lui est attribué une

Les types prédéfinis

La taille mémoire correspondant aux différents types

Les types de base en C concernent les caractères, les entiers et

Ils sont désignés par les mots-clefs suivants :

Prof. R. HANNANE (FSSM) Programmation II 17 / 52

Les types prédéfinis

Le mot-clef char désigne un objet de type caractère.

Un char peut contenir n’importe quel élément du jeu de

La plupart du temps, un objet de ce type est codé sur un

Une des particularités de ce type en C est qu’il peut être

Prof. R. HANNANE (FSSM) Programmation II 18 / 52

Les types prédéfinis

Par exemple, si c est de type char, l’expression c + 1 est valide.

Le programme suivant imprime le caractère ’B’:

Les types prédéfinis

Le mot-clef désignant le type entier est int.

Il peut être précédé d’un attribut de précision (short ou long)

Un objet de type short int a au moins la taille d’un char et au