Cours Langages de Programmation
Chapitre 4 Les instructions de contrôle
1. Les instructions conditionnelles
1.1. Instruction « if else »
if ( expression )
{
} bloc d'instructions 1 ;
els
e
{
bloc d'instructions 2;
}
- Si l'expression fournit une valeur différente de zéro, alors le bloc d'instructions 1 est
exécuté
- Si l’expression fournit la valeur zéro,
alors le bloc d'instructions2 est exécuté
Attention !!! Les ( ), devant « if », sont obligatoires.
Remarques :
o Les { } ne sont pas nécessaires lorsque les blocs ne comportent qu'une seule
instruction.
o On peut avoir des « if » imbriqués
o
Exemples :
if (a >
b) max
= a;
else
max = b;
if (A-B)
printf("A est différent de B\n");
else
printf("A est égal à B\n");
int a,b,c;
…;
if (!a) //équivalent if (a==0)
{
printf(“ cas où a = = 0 ”);
…;
}
else // commentaire : cette partie traite le cas où a != 0
{
if (!b)
[Link]. Walid Ben Harrath- 1
Cours Langages de Programmation
[Link]. Walid Ben Harrath- 2
Cours Langages de Programmation
{
printf(“cas où a != 0 et b = = 0”);
…;
}
else
{
printf(“cas où a != 0 et b != 0 ”);
…. ;
}
}
1.2. Instruction switch
C’est un moyen qui permet des choix multiples uniquement sur des entiers ou des caractères.
switch (choix)
{
case cst1 : liste d'instructions
1 ; break;
case cst2 : liste d'instructions
1 ; break;
….
default : liste instructions N ;
}
Remarques :
o Le bloc default n’est pas obligatoire
o « choix » doit être de type char ou int
o choix, cst1, cst2 et les autres valeurs sont de même type
L’instruction break permet de sortir de l’instruction switch. Elle est importante car si on ne la
met pas après chaque cas d’exécution alors toutes les instructions après ce cas seront
exécutées (bien sur s’ils ne sont pas suivis d’une autre instruction break).
Exemple
: int mois ;
scanf(" %d" ,&mois) ;
switch ( mois )
{
case 1 : printf(" janvier" ) ; break
; case 2 : printf(" fevrier" ) ;
break ;
…
case 12 :printf(" décembre" );
break ; default : printf(“erreur”)
}
[Link]. Walid Ben Harrath- 3
Cours Langages de Programmation
2. Les instructions itératives
2.1. Structure « while »
while (expression)
{
bloc d'instructions ;
}
Tant que l'expression fournit une valeur différente de zéro, le bloc d'instructions est
exécuté.
Les { } ne sont pas obligatoires, si le bloc d’instruction contient une seule instruction.
Les parenthèses ( ) devant while sont obligatoires.
Exemple
1: /* Afficher les nombres de 0 à 9
*/ int I = 0;
while (I<10)
{
printf("%d \n",
I); I++;
}
/* Afficher les nombres de 0 à 9
*/ int I = 0 ;
while (I<10)
printf(“%d\n”,I++);
/* Afficher les nombres de 1 à
10 */ int I = 0 ;
while (I<10)
printf(“%d\n”,++I);
Exemple
2: /* faire la somme des N premiers terme entier*/
int somme=0, N, i = 0;
while (i<N)
{
[Link]. Walid Ben Harrath- 4
Cours Langages de Programmation
somme += i;
i++ ;
}
Exemple
3:
/* Afficher des caractères */
unsigned char c=0;
while (c<255)
printf("%c \n", c++);
2.2. Structure « do while »
do
{
bloc d’instructions;
} while ( expression ) ;
- Le bloc d'instructions est exécuté au moins une fois et jusqu’à ce que l'expression fournit
une valeur égale à zéro (eq false).
- Les { } ne sont pas obligatoires, si le bloc d’instruction contient une seule instruction.
do - while est comparable à la structure Répéter…jusqu'à de l’algorithme à la différence
que la condition finale est inversée logiquement.
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.
Une application typique de do - while est la saisie de données qui doivent remplir une certaine
condition.
Exemple1: Lecture d’un nombre réel dans l’intervalle [1
, 10] float N;
do
{
[Link]. Walid Ben Harrath- 5
Cours Langages de Programmation
printf("Introduisez un nombre entre 1 et 10 :");
scanf("%f", &N);
}
while (N<1 || N>10);
Exemple2 : division de deux entiers (diviseur doit être différent
de zéro) int n, div;
printf("Entrez le nombre à diviser : ");
scanf("%d", &n);
do
{
printf("Entrez le diviseur ( != 0) : ");
scanf("%d", &div);
}
while (!div); //while (div==0)
printf("%d / %d = %f\n", n, div, (float)n/div);
Exemple3 : Lecture d’un nombre réel positif
float
N; do
{
printf("Entrer un nombre (>= 0) : ");
scanf("%f", &N)
}
while (N < 0);
printf("La racine carrée de %.2f est %.2f\n", N, sqrt(N));
2.3. Structure « for »
La structure pour en langage algorithmique est utilisées pour faciliter la programmation de
boucles de comptage. La structure for en C est plus générale et beaucoup plus puissante.
for ( expr1 ; expr2 ; expr3 )
{
bloc d'instructions ;
}
Est équivalente à :
expr1;
while (expr2 )
{
bloc d'instructions
expr3 ;
}
[Link]. Walid Ben Harrath- 6
Cours Langages de Programmation
expr1 est évaluée une fois avant le passage de la boucle. Elle est utilisée pour initialiser les
données de la boucle.
expr2 est évaluée avant chaque passage de la boucle. Elle est utilisée pour décider si la boucle
est répétée ou non.
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.
En pratique, les parties expr1 et expr2 contiennent souvent plusieurs initialisations ou
réinitialisations, séparées par des virgules.
Exemple1:
/* affichage des carrés des nombres entiers compris entre 0
et 20 */ int I;
for (I=0 ; I<=20 ; I++)
printf("Le carré de %d est %d \n", I, I*I);
/* Autre version : n’est pas
lisible */ int I;
for (I=0 ; I<=20 ; printf("Le carré de %d est %d \n", I, I*I), I++)
;
Exemple2 : Somme des nombres de 1 à 100
int n, tot;
for (tot=0, n=1 ; n<101 ; n++)
tot+=n;
printf("La somme des nombres de 1 à 100 est %d\n", tot);
[Link]. Walid Ben Harrath- 7
Cours Langages de Programmation
Chapitre 5 Les tableaux
1. Les tableaux à une dimension
- Déclaration et mémorisation
Déclaration
Déclaration de tableaux en C :
TypeSimple NomTableau [nombreCases] ;
Les noms des tableaux sont des identificateurs.
Exemples :
int notes [8] ; /* déclaration d’un tableau nommé notes, de type int et de
dimension 8 */ char tab [100] ; /* déclaration d’un tableaux nommé tab, de type
char et de dimension 100 */ float moy[40] ; /* déclaration d’un tableau nommé
moy, de type float et de dimention 100 */
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:
char A[5] = {‘A’, 66, 70, ‘C’, 240};
……… 65 66 70 67 240 ………..
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.
- Initialisation et réservation automatique
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};
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
8
Cours Langages de Programmation
restantes sont initialisées par zéro.
9
Cours Langages de Programmation
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
float B[] = {-1.05, 3.33, 87e-5, -12.3E4};
==> Réservation de 4*sizeof(float) octets
int C[] = {1, 0, 0, 1, 1, 1, 0, 1, 0, 1};
==> Réservation de 10*sizeof(int) octets
- 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 :
- Affichage et affectation
La structure for se prête particulièrement bien au travail avec les tableaux. La plupart des
applications se laissent implémenter par simple modification des exemples-types de l'affichage et
de l'affectation.
Affichage du contenu d'un tableau : exemple
int A[5];
int I; /* Compteur
*/ for (I=0; I<5;
I++)
printf("%d ", A[I]);
Affectation avec des valeurs provenant de l'extérieur : exemple
int A[5];
int I; /* Compteur
*/ for (I=0; I<5;
I++)
scanf("%d", &A[I]);
10
Cours Langages de Programmation
2. Les tableaux à deux dimension
- Déclaration et mémorisation
déclaration
Déclaration de tableaux à deux dimensions en C
TypeSimple NomTabl[NbreLigne][NbreCol];
Exemples :
double A[2][5] ; /* déclaration d’un tableau à deux dimension nommé A et de type
double */ char B[4][2] ; /* déclaration d’un tableau à deux dimension nommé B
et de type char */
Mémorisation
Comme pour les tableaux à une dimension, le nom d'un tableau est le représentant de l'adresse du
premier élément du tableau (c-à-d l'adresse de la première ligne du tableau). Les composantes d'un
tableau à deux dimensions sont stockées ligne par ligne dans la mémoire.
Exemple: Mémorisation d'un tableau à deux dimensions
short A[3][2] = {{1, 2 },
{10, 20 },
{100, 200}};
…………. 1 2 10 20 100 200 ………..
Lors de la déclaration d'un tableau, on peut initialiser les composantes du tableau, en indiquant la
liste des valeurs respectives entre accolades. A l'intérieur de la liste, les composantes de chaque
ligne du tableau sont encore une fois comprises entre accolades. Pour améliorer la lisibilité des
programmes, on peut indiquer les composantes dans plusieurs lignes.
Exemples
int A[3][10] ={{ 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};
float B[3][2] = {{-1.05, -1.10 },
{86e-5, 87e-5 },
{-12.5E4, -12.3E4}};
Lors de l'initialisation, les valeurs sont affectées ligne par ligne en passant de gauche à droite. Nous
ne devons pas nécessairement indiquer toutes les valeurs: Les valeurs manquantes seront
initialisées par zéro. Il est cependant défendu d'indiquer trop de valeurs pour un tableau.
Si le nombre de lignes L n'est pas indiqué explicitement lors de l'initialisation, l'ordinateur
réserve automatiquement le nombre d'octets nécessaires.
11
Cours Langages de Programmation
int A[][10] = {{ 0,10,20,30,40,50,60,70,80,90},
{10,11,12,13,14,15,16,17,18,19},
{ 1,12,23,34,45,56,67,78,89,90}};
- Accès aux composantes
L’accès à un élément d’un tableau à deux dimensions se fait selon le schéma suivant :
NomTableau[Ligne][Colonne]
Les éléments d'un tableau de dimensions L et C se présentent de la façon suivante:
A[0][0] A[0][1] A[0][2] . . . A[0][C-1]
A[1][0] A[1][1] A[1][2] . . . A[1][C-1]
A[2][0] A[2][1] A[2][2] . . . A[2][C-1]
. . . . . . . . . . . . . . .
A[L-1][0] A[L-1][1] A[L-1][2] . . . A[L-1][C-1]
- Affichage et affectation
Lors du travail avec les tableaux à deux dimensions, nous utiliserons deux indices ([Link]: I et J), et
la structure for, souvent imbriquée, pour parcourir les lignes et les colonnes des tableaux.
Affichage du contenu d'un tableau à deux dimensions
int A[5][10];
int I,J;
/* Pour chaque ligne ...
*/ for (I=0; I<5; I++)
{
/* ... considérer chaque composante
(colonne) */ for (J=0; J<10; J++)
printf("%7d", A[I][J]);
}
Affectation avec des valeurs provenant de l'extérieur
int A[5][10];
int I,J;
/* Pour chaque ligne ...
*/ for (I=0; I<5; I++)
/* ... considérer chaque composante
(colonne) */ for (J=0; J<10; J++)
scanf("%d", &A[I][J]);
12
Cours Langages de Programmation
Chapitre 6 LES FONCTIONS
1. Définition de fonctions
Définition d’une fonction en C :
TypeRésultatRetourné NomFonction (TypePar1 NomPar1, TypeParN NomParN,… )
{
déclarations locales ;
instructions ;
}
Exemple 1 :
int somme_carre( int i , int j ) /* liste des noms et types des paramètres formels.
on ne peut pas écrire : int somme_carre( int i , j ) */
{
int resultat; /* declaration
locale */ resultat = i*i + j*j;
return(resultat);/* la valeur retournée, de type int */
}
Remarque :
Si nous choisissons un nom de fonction qui existe déjà dans une bibliothèque, notre fonction
cache la fonction prédéfinie.
Une fonction peut fournir comme résultat:
un type simple
une structure (définie par struct ),
une réunion (définie par union ),
un pointeur,
void (la fonction correspond alors à une 'procédure')
Une fonction ne peut pas fournir comme résultat des tableaux, des chaînes de caractères ou
des fonctions. Mais, il est cependant possible de renvoyer un pointeur sur le premier élément
d'un tableau ou d'une chaîne de caractères.
Si une fonction ne fournit pas de résultat, il faut indiquer void (vide) comme type du résultat.
Si une fonction n'a pas de paramètres, on peut déclarer la liste des paramètres comme (void)
ou simplement comme () .
Le type par défaut est int; autrement dit: si le type d'une fonction n'est pas déclaré
explicitement, elle est automatiquement du type int.
Il est interdit de définir des fonctions à l'intérieur d'une autre fonction (comme en Pascal).
En principe, l'ordre des définitions dans le texte du programme ne joue pas de rôle, mais
chaque fonction doit être déclarée ou définie avant d'être appelée.
13
Cours Langages de Programmation
2. Passage des paramètres par valeur
Exemple: fonction qui calcule le factoriel d’un nombre
N>0 Long int factoriel (int N)
{
long int fact = 1 ;
while (N>0)
{
fact=fact*N; N
--;
}
return (fact);
}
/* fonction qui calcule et affiche le factoriel des 10 premiers
entiers */ void calcfact(void)
{
int L;
for (L=1; L<10; L++)
printf(“%d”,factoriel(L));
}
Au moment de l'appel, la valeur de L est copiée dans N. La variable N peut donc être
décrémentée à l'intérieur de factoriel, sans influencer la valeur originale de L.
3. Passage de l'adresse d'un tableau à une dimension
Cela consiste à fournir l'adresse d'un élément du tableau. En général, on fournit l'adresse du
premier élément du tableau, qui est donnée par le nom du tableau.
Dans la liste des paramètres d'une fonction, on peut déclarer un tableau par le nom suivi de
crochets ou simplement par un pointeur sur le type des éléments du tableau.
Lors d'un appel, l'adresse d'un tableau peut être donnée par le nom du tableau, ou par l'adresse
d'un élément quelconque du tableau.
Exemple:
void LIRE_TAB(int N, int PTAB[])
{ int i ;
printf("Entrez %d valeurs : \n", N);
for (i=0; i<N; i++)
scanf("%d", PTAB[i]);
}
Lors de l’appel de ces différentes
fonctions : int tab[5] ;
LIRE_TAB (5, tab) ;
LIRE_TAB1 (5,&tab[0]) ;
Remarque :
Pour qu'une fonction puisse travailler correctement avec un tableau qui n'est pas du type char, il
faut aussi fournir la dimension du tableau ou le nombre d'éléments à traiter comme paramètre,
sinon la fonction risque de sortir du domaine du tableau.
14