Département

A.U. 2019/2020
Informatique
&
Méthodes Syntaxe du langage C Section : 1ère IAG
Quantitatives
Partie I Cours : F.Bouafif / B.Fessi

1. Structure d’un programme

- Un programme en langage C’est une suite d'instructions.
- Un programme en C est un ensemble de fonctions, parmi ces fonctions, il existe
une fonction de démarrage dont le nom est "main" appelée fonction principale.
syntaxe :

#include <………> // déclaration des bibliothèques

void main( ) // la fonction ne prend aucun paramètre et ne retourne pas de valeur

{ // begin : début du programme

Cstes ; // déclaration des constantes et des variables

Variables;

instruction1 ; // corps du programme : les instructions

instruction2 ;
….
} // fin: fin du programme

Les bibliothèques les plus utilisés :

#include < Stdio.h> : pour les fonctions Entrées-sorties standard (printf(), scanf(),…)
#include < math.h> : pour les fonctions mathématiques prédéfinies (cos(), abs(),…)
#include < Stdlib.h> : pour les fonctions d’usage général comme conversion de chaines
de caractères en valeur numérique ( atoi(), …)
#include < String.h> : pour les fonctions des chaînes de caractères prédéfinies
(length(),…)

Remarque : un point-virgule ( ; ) est inséré après chaque déclaration et chaque instruction

Exemple :
#include <stdio.h>
void main()
{
printf (“bonjour”);
}
1
2. Les commentaires

- Un commentaire est utilisé pour faciliter la compréhension du programme.

- Les commentaires sont ignorés par le compilateur.
- Un commentaire sur plusieurs lignes débute par « /* » et se termine par « */ ».
- Un commentaire sur une même ligne débute par « // »

3. Les types de bases : 4 types de bases les autres sont dérivés de ceux-ci :

Codage
Exemples de
Type Signification en Peut être
valeur
mémoire

Caractère 'a‘, 'A‘, 'z‘, 'Z‘,

char 1 octet signed,unsigned
unique '\n’,...

Nombre 0, 1, -1, 4589, 2 ou 4 Short, long,

int
entier 32000,... octets signed,unsigned

Nombre réel 0.0, 1.0, 3.14,

float 4 octets
simple 5.32, -1.23,…

Nombre réel
0.0, 1.0E–10, 1.0 ,
double double 8 octets Long
-1.34567896,…
précision

4. Fonctions d’entrées/sorties standards :

4.1. La fonction « printf() » : permet d’afficher à l’écran du texte des valeurs de
variables ou des résultats d’expression
Syntaxe:
printf ("format", expr1, expr2, …);

- expr1,…: sont les variables et les expressions dont les valeurs sont à représenter
- format : est une chaîne de caractères qui peut contenir :
 du texte
• des spécificateurs de format : un ou deux caractères précédés du symbole
%, indiquant le format d’affichage

2
 • des séquences d’échappement (‘\n’, ‘\t’, …)
L’affichage du texte peut être contrôlé à l’aide des séquences d’échappement :

4.2. La fonction « scanf() » : permet de lire les données à partir du clavier

Syntaxe :

scanf( " format" , AdrVar1, AdrVar2, AdrVar3,…);

 Format : le format de lecture de données, est le même que pour printf

 AdrVar1, AdrVar2, … : adresses des variables auxquelles les données seront
attribuées. L’adresse d’une variable est indiquée par le nom de la variable
précédé du signe « & »

5. Les variables :
5.1. Déclaration :
Syntaxe :

Type identificateur1, identificateur2, …,…. ;

 Type : int, float, char, …

 Identificateur : c’est une suite de nombre ou de lettre
- Le premier caractère est obligatoirement une lettre
- Le caractère « _ » (souligné) est considérer comme une lettre
- Le C distingue les minuscules des majuscules

3
 Exemple : Compte, COMPTE, compte : trois identificateurs valides qui sont
différents
Exemples identificateurs non valide :
3eme commence par un chiffre
x#y caractère non autorisé (#)
no-commande caractère non autorisé (-)
taux change caractère non autorisé (espace)

5.2. 5.2. Affectation :

int x ; float z ;
x=4 ; //affectation z=6.8 ;

Une variable peut être initialisée lors de sa déclaration.

Exemple : int y=3 ; float x=2.7 ; char c= " a" ;

6. Les constantes :
Déclaration d'une variable, dont la valeur sera constante pour tout le programme.
Syntaxe
const type nom_constante = expression

Exemple:
void main()
{
const float PI = 3.14159; // déclaration d’une constante réel PI
float perimetre, rayon = 8.7; // déclaration des variables, la variable rayon est initialisée

perimetre = 2*rayon*PI; // calcul du périmètre du cercle

printf(“le perimetre =%f\n”,perimetre) // affichage de la valeur du périmètre du cercle

7. Les opérateurs
7.1. Les opérateurs mathématiques
Le C propose les opérateurs arithmétiques classiques suivants :
+ addition
- soustraction
* multiplication
/ division
% modulo (reste de la division entière)

7.2. Les opérateurs de comparaisons

< plus petit

<= plus petit ou
> plus grand
>= plus grand ou
== é=lu
!= différent

4
 7.3. Les opérateurs logiques

&& ET
|| OU
! non

Remarque : Le type booléen n'existe pas. Le résultat d'une expression logique vaut 1 si elle est
vraie et 0 sinon. Réciproquement, toute valeur non nulle est considérée comme vraie et la valeur
nulle comme fausse.
Exemple :
int i;
float f;
char c;
i = 7; f = 5.5; c = 'w';
f>5 ====> vrai (1)
(i + f) <= 1 ====> faux (0)
c == 'w‘ ====> vrai (1)
c != 'w' ====> faux (0)
(i >= 6) && (c == 'w') ====> vrai (1)
(i >= 6) || (c == 119) ====> vrai (1)

 !expr1 est : vrai (1) si expr1 est faux

faux (0) si expr1 est vrai ;

 expr1&&expr2 est : vrai (1) si les deux expressions expr1 et expr2 sont vraies
faux(0) sinon.
L'expression expr2 n'est évaluée que dans le cas où l'expression
expr1 est vraie ;
 expr1 || expr2 = vrai(1) si expr1=(1) ou expr2=(1) et faux sinon. L’expression expr2
n'est évaluée que dans le cas où l'expression expr1 est fausse.

7.4. Opérateurs d’affectations

- En pratique, nous retrouvons souvent des affectations comme : i=i+2

- En C, nous utiliserons plutôt la formulation plus compacte : i += 2
- Les opérateurs d’affectation
Ajouter à : + = Multiplier par : *= Modulo : %=
Diminuer de : - = Diviser par : /=
- Syntaxe :
expression1 op= expression2

(expression1) = (expression1) op (expression2)

- Les affectations les plus fréquentes sont du type : i = i + 1 et i = i – 1

- Pour C nous disposons deux opérateurs inhabituels pour ces affectations :
 i++ ou ++i : pour l'incrémentation (augmentation d'une unité)
 i-- ou --i : pour décrémentation (diminution d'une unité)

5
 - Ces opérateurs peuvent être préfixés (avant la variable) ou postfixés (après la variable).
- incrémenter/décrémenter une variable et en même temps affecter sa valeur à une autre
variable. Dans ce cas, nous devons choisir entre la notation préfixe et postfixe :
 x = i++ passe d'abord la valeur de i à x et incrémente après
 x = i-- passe d'abord la valeur de i à x et décrémente après
 x = ++i incrémente d'abord et passe la valeur incrémentée à x
 x = --i décrémente d'abord et passe la valeur décrémentée à x
Exemple :

#include <stdio.h>
void main()
{
int i, j = 5;
i++ ;
i = ++j;  I=j ;

printf("i=%d, j=%d\n", i, j);  i=6, j=6

j = 5;
i=j ;
i = j++;  j++ ;

printf("i=%d, j=%d\n", i, j);  i=5, j=6

8. Les structures de contrôles

8.1. Les structures conditionnelles :
8.1.1. IF : condition simple
Syntaxe
if (expression de comparaison)
{
Instructions ;
}

Exemple :
if (a<b)
{
printf(‘’la valeur de a est inférieur à la valeur de b\n’’);
}

8.1.2. IF…ELSE
Syntaxe Exemple
if (expression de comparaison) if (a<b)
{ {
Instructions1 ; printf(‘’la valeur de a est inférieur à b’’);
} }
else else
{ {
Instructions2 ; printf(‘’la valeur de b est inférieur à a’’);6
} }
 8.1.3. IF imbriqué
Syntaxe Exemple
if ( expression 1) void main()
{ {
instruction(s)1; int A,B;
} printf(" Donner 2 entiers : ") ;
else scanf("%d %d",&A, &B) ;
{ if(A>B)
if (expression2) {
{ printf("%d est plus grand que %d\n",A,B) ;
instruction(s)2; }
} else
else {
{ if(A<B)
instruction(s)3; {
} printf("%d est plus petit que %d\n",A,B) ;
} }
else
{
printf("%d est egal a %d\n",A,B) ;
}
}
}
Remarque :
Le langage C possède une paire d’opérateurs (? et : ) qui peut être utilisée à la place de la structure
conditionnelle simple.
Syntaxe :
expr1 ? expr 2 : expr 3 ;

- Si expr1 fournit une valeur != 0, alors expr2 est fournie comme résultat
- Si expr1 fournit une valeur == 0, alors expr 3 est fournie comme résultat
- Si expr2 ou expr3 contiennent plusieurs instructions, elles doivent être séparées par des
virgules. Dans ce cas, la valeur retournée sera celle de la dernière instruction du bloc
exécuté
Exemple :

if (A>B)
max=A ;  max=(A>B) ?A :B ;
else
max= B ;

8.1.4. Switch…Case
Syntaxe switch (variable)
{
case <val1> : instruction(s) 1 ;
break;
case <val2> : instruction(s) 2 ;
break;
……………
Case <valn> : instruction(s) n ; 7
break;
default : instructions ;
}
 - variable : sera comparée à chaque valeur (val1, val2,…valn)
- Instruction 1 sera exécutée si variable==val1
- Le mot clé break permet de quitter la structure switch
- Le bloc défault est optionnel il sera exécuté si la valeur saisie ne correspond à aucun des
cas
Exemple : écrire un programme qui permet d’afficher le nom du mois selon le numéro saisi par
l’utilisateur
#include <stdio.h>
void main()
{
int mois; //déclaration des variables

printf(" donnez le nom du mois selon le numéro saisi \n"); //texte affiché sur l’écran
printf(" Saisir le numéro du mois \n"); /* lire et
scanf(" %d" ,&mois) ; écrire le numéro du mois */

switch ( mois )
{
case 1 : printf(" janvier" ) ; break ;
case 2 : printf(" fevrier" ) ; break ;
case 3 : printf(" Mars" ) ; break ;
case 4 : printf(" avril" ) ; break ;
case 5 : printf(“mai" ) ; break ;
case 6 : printf(" juin" ) ; break ;
case 7 : printf(" juillet" ) ; break ;
case 8 : printf(" aout" ) ; break ;
case 9 : printf(" septembre" ) ; break ;
case 10 : printf(" Octobre" ) ; break ;
case 11 : printf(" Novembre" ) ; break ;
case 12 :printf(" décembre" ); break ;
default : printf(“erreur, nombre invalide”);
}
}

8.2. Les structures répétitives :

8.2.1. Boucle « while… »
Syntaxe exemple : Afficher « bonjour » 4 fois .

while (condition ) #include <stdio.h>

{ int main()
bloc_d’instructions ; {
} /* déclaration et initialisation du Compteur*/
int i = 1;
while ( i<=4 ) /* tester la condition*/
{
printf(“ Bonjour = %d \n ”, i);
i++ ; /*incrémentation compteur*/
}
}

8
 8.2.2. Boucle « do… while »
Syntaxe Exemple

do #include <stdio.h>
{ int main()
bloc_d’instructions ; {
/* déclaration et initialisation du Compteur*/
} while (condition) ; int i = 0;
do /* tester la condition*/
{
printf(“ Bonjour = %d \n ”, i);
i++ ; /*incrémentation compteur*/
}while(i<4)
}

8.3.2. Boucle « for… »

Syntaxe :

for (initialisation; condition; incrémentation)

{
bloc d’instructions;
}

Exemple : écrire un programme qui permet d’afficher les nombres impairs de 1à 10

#include <stdio.h>
void main()
{
int i; /*déclaration*/
printf("Les nombres impairs sont:\n" );
for( i=1; i<=10 ; i++) /* boucle for*/
{
if(i%2!=0)
{
printf(" %d\n ", i); /* traitement*/
}
}
}

Remarques :
- En C il existe aussi des boucles infinies !!! C’est une boucle dont la condition de sortie n’a
pas été définie.
o Résultat non affiché ;
o Epuisement des ressources de l’ordinateur ;
o Blocage des tâches de l’ordinateur.

9
 Différence entre les boucles ; « while », « «do…while », « for »

9. Les tableaux
9.1. Tableau à une dimension
a. Syntaxe :

Type nom_tableau[dimension]

Exemple : float notes[20] ; // tableau de 20 notes

b. Initialisation : Un tableau peut être initialisé dès la déclaration.
Exemple : int A[5] = {4, 24, 3, 22, 1}; /* tableau de cinq entiers*/

c. Remplir et affichage : pour remplir ou afficher le contenu d’un tableau, on utilise

une boucle for et un compteur qui commence par 0.

#include <stdio.h>
#include <conio.h>
void main()
{
/* Déclaration du tableau initialisé */
int t[5];

/* Déclaration d'un compteur */

int i;
/* Remplissage du tableau */
for(i=0; i<5; i++)
{
printf("Saisir une valeur: t[%d]= ",i);
scanf("%d", &t[i]);
}
/* afficher le contenu du tableau */
printf((" le contenu du tableau:");

for(i=0; i<5; i++)

{
printf(" t[%d] = %d\n ", i, t[i]);
} 10

}
9.2. Tableau à deux dimensions
a. Syntaxe

Type nom_tableau[nb_ligne] [nb_colonne]

Exemple : float notes [20][5] ;

b. Initalisation :
- Les valeurs sont initialisées ligne par ligne de gauche à droite.
-Les composantes de chaque ligne du tableau sont comprises entre accolades.
Exemples : float notes[2] [2] = {{12, 13}, {9, 11}};
Ou bien
float notes[2] [2] = {{12, 13},
{9, 11}};
d. Remplir et affichage : pour remplir ou afficher le contenu d’un tableau on utilise
deux boucles for une pour les lignes et l’autre pour les colonnes.
#include <stdio.h>
void main()
{
/* Déclaration du tableau */
int M[5][2];
/* Déclaration d'un compteur */
int i,j;
/* Remplissage du tableau */
for(i=0; i<5; i++)
{
Printf("Saisir les valeurs de la ligne %d\n",i);
for (j=0; j<2; j++)
{
printf("M[%d][%d]=",i,j);
scanf("%d", &m[i][j]);
}
}
/* afficher le contenu du tableau */
printf((" le contenu du tableau:");
for(i=0; i<5; i++)
{
for(j=0; j<2; j++)
{
printf("M[%d ][%d]=%d\n", i,j, M[i][j]);
}
}
}

11