Les structures de contrôle (Suite)

Principales fonctions d’entrées-sorties standard

Les Tableaux
Les Fonctions

23/12/2020 Programmer en langage C 2

La structures de contrôle : Switch

La syntaxe du langage C
 L’instruction switch est une structure de
contrôle la plus utilisé en langage C. Elle permet
à votre programme d’exécuter différentes
instructions en fonction d’une expression qui
pourra avoir plus de deux valeurs.

23/12/2020 Programmer en langage C 3

structures de contrôle : Switch
#include<stdio.h>
main() {
int a,b,y;

La syntaxe du langage C
char operateur;
printf(‘’ Entrez un opérateur (+, -,* ou /):’’);
scanf(‘’%c’’,& operateur);
printf(‘’ Entrez deux entiers:’’);
scanf(‘’%d’’,&a); scanf(‘’ %d’’,&b);
switch(operateur){
case’-’ : y=a-b; printf(‘’%d’’,y);break;
case’+’ : y=a+b; printf(‘’%d’’,y); break;
case’*’ : y=a*b; printf(‘’%d’’,y); break;
case’/’ : y=a/b; printf(‘’%d’’,y); break;
default : printf(‘’opérateur inconnu\n’’);break;
}
}
23/12/2020 Programmer en langage C 4
structures de contrôle : while
 L’instruction while permet de répéter des instructions,
tant qu'une condition est vérifiée.

La syntaxe du langage C
 Syntaxe
 Forme 1

while (condition)
une-instruction;

 Forme 2
while (condition) {

des instructions;

}
}

23/12/2020 Programmer en langage C 5

structures de contrôle :while
 La boucle while fonctionne de la façon suivante:
1. si cette condition est fausse, l’instruction while se termine,
2. si la condition est vraie les instructions sont exécutées

La syntaxe du langage C
 Exemple
#include <stdio.h>
main (){
int i=1, N;
printf(” donnez N=\n");
scanf("%d",&N);
while (i <= N) {
printf("%d ", i);
i = i+1;}
system(”pause");
}

23/12/2020 Programmer en langage C 6

structures de contrôle :while
 while imbriqué
#include <stdio.h>

La syntaxe du langage C
#define MAX 3
main() {
int i=0,j;
while (i < MAX ) {
j=0;
while (j < MAX ) {
printf(" position : %d \t %d\n",i,j);
j++;
}
i++; }

23/12/2020 Programmer en langage C 7

structures de contrôle : do-while
 L'instruction do-while, exécute le bloc d'instructions
tant qu’une condition reste vraie. Alors dans cette
boucle le test de la condition s’effectue à la fin de la

La syntaxe du langage C
boucle.
 Syntaxe
 Forme 1
do
une-instruction;
while (condition);

 Forme 2
do {
Des instructions;
} while (condition);

23/12/2020 Programmer en langage C 8

structures de contrôle : for
 A l’instar des instructions while et do-while l’instruction for
permet d’exécuter un certain nombre de fois un bloc d’une ou
plusieurs instructions.

La syntaxe du langage C
 Syntaxe:
 for( [expression1] ; [expression2] ; [expression3 ]) {
liste d’instructions
}
Exemple : For (i=0 ; i<5 ; i++)

 Dans la construction de for :

○ expression1 : effectue les initialisations nécessaires avant
l’entrée dans la boucle;
○ expression2 : est le test de continuation de la boucle ; le test
est évalué avant l’exécution du corps de la boucle;
○ expression3 : est évaluée à la fin du corps de la boucle.

23/12/2020 Programmer en langage C 9

structures de contrôle : for
 Remarques
 En pratique, expression1 et expression3 contiennent
plusieurs initialisations séparées par des virgules.

La syntaxe du langage C
○ for(i=0,j=1,k=5 ;…….….…. ;………………)

 L’expression 1 et expression 3 peuvent être absente(les

points-virgules doivent apparaître.
○ i=1;
for(;i<=5;) { for(i=1 ; i<=5 ; i++)
printf(‘’%d fois\n’’,i); printf(‘’%d fois\n’’,i);
i++;
}

23/12/2020 Programmer en langage C 10

structures de contrôle : for
 Remarques :par définition l’instruction de for
for ( expression1 ; expression2 ; expression3 )

La syntaxe du langage C
{
liste d’instructions;
}
>>> Est équivalente à
expression1;
while(expression2)
{
liste d’instructions;
expression3;
}

23/12/2020 Programmer en langage C 11

Les structures de contrôle :for
 Exemples
 Programme pour calculer la somme de 1 à 100

La syntaxe du langage C
int n,somme;
for(somme=0,n=1;n<=100;n++)
somme = somme + n ;
printf(’’la sommes des nombres de 1 à 100 est %d \n’’,total);

 Programme pour calculer la factorielle d’un entier n:

int n, i,fact;
for(fact=1,i=1;i<=n;i++)
fact = fact * i;
printf(’’%d!= %d \n’’,n,fact);

23/12/2020 Programmer en langage C 12

Les structures de contrôle : break

 Instruction break

La syntaxe du langage C
 On a vu le rôle de l’instruction break; au sein d’une
instruction de branchement multiple switch.
 L’instruction break peut, plus généralement, être
employée à l’intérieur de n’importe quelle boucle (for ;
while ; do-while). Elle permet l’abandon de la structure
et le passage à la première instruction qui suit la
structure.
 En cas de boucles imbriquées, break fait sortir de la
boucle la plus interne.

23/12/2020 Programmer en langage C 13

Les structures de contrôle : break

 Instruction break : exemple

La syntaxe du langage C
#include <stdio.h>
main( ){
int i;
for (i = 1 ; i<=10 ; i++){
printf(’’début tour %d\n’’ ,i) ;
printf(’’ bonjour\n’’);
if (i ==3) break ;
printf(" fin tour %d\n", i) ;
}
printf(" après la boucle \n") ;
}
23/12/2020 Programmer en langage C 14
 Instruction break : exemple

#include <stdio.h> Evaluation:

main( ){

La syntaxe du langage C
Début tour 1
int i; bonjour
for (i = 1 ; i<=10 ; i++) { fin tour 1

printf(’’début tour %d\n’’ ,i) ; Début tour 2

printf(’’ bonjour\n’’); bonjour

if (i ==3) break ; fin tour 2

Début tour 3
printf(" fin tour %d\n", i) ;
bonjour
}
Après la boucle
printf(" après la boucle \n") ;
}

23/12/2020 Programmer en langage C 15

Principales fonctions d’entrées-sorties
standard
 Il s’agit des fonctions de la librairie standard stdio.h

La syntaxe du langage C
utilisées avec les unités classiques d’entrées-sorties,
qui sont respectivement le clavier et l’écran.
 Ces fonctions sont:

 getchar

 putchar

 printf

 scanf

23/12/2020 Programmer en langage C 16

Principales fonctions d’entrées-sorties
standard
 La fonction getchar

La syntaxe du langage C
 La fonction getchar permet la récupération d’un seul
caractère à partir du clavier. La syntaxe d’utilisation de
getchar est la suivante : var=getchar();
 Notez que var doit être de type char. Exemple :
#include <stdio.h>
main() {
char c;
printf("Entrer un caractère:");
c = getchar();
printf("Le caractère entré est %c\n",c);
}

23/12/2020 Programmer en langage C 17

Principales fonctions d’entrées-sorties
standard
 La fonction putchar

La syntaxe du langage C
 permet l’affichage d’un seul caractère sur l’écran de
l’ordinateur. putchar constitue alors la fonction
complémentaire de getchar. La syntaxe d’utilisation est
la suivante : putchar(var);
 où var est de type char. Exemple :
#include <stdio.h>
main() {
char c;
printf("Entrer un caractère:");
c = getchar();
putchar(c);
}

23/12/2020 Programmer en langage C 18

 Les types dérivés
Les Tableaux

23/12/2020 Programmer en langage C 19

2- Les tableaux
 Ensemble des données de même type ,Il est souvent
nécessaire de mémoriser un grand nombre d’éléments
identiques

Les types dérivés

 Définition

 Un tableau représente un ensemble d’emplacements mémoire qui

portent le même nom et contiennent le même type de données.
Chacun de ces emplacements est un éléments du tableau.

 Un tableau est une suite des éléments de même taille.

23/12/2020 Programmer en langage C 20

Les tableaux
 Les tableaux à une dimensions
 Un tableau à une dimension ne possède qu’un index.
Un index est le nombre entre crochets qui suit le nom
du tableau. Il indique le nombre d’éléments du tableau.

Les types dérivés

 Déclarations
<type simple> Nom_du_tableau[nombre_elements];
○ Type simple : définit le type d’élément que contient le tableau
○ Nom du tableau : est le nom qu’on donne au tableau, ce nom
suit les mêmes règles qu’un nom de variable.
○ Nombre_elements : est une expression constante entière
positive, qui exprime la taille du tableau.
 Exemple:
○ char caractere[12];
○ int Classe[10];
○ float Notes[100];
23/12/2020 Programmer en langage C 21
Les tableaux
 Les tableaux à une dimensions
 Accès aux composantes d’un tableau
○ Pour accéder à un élément du tableau, il suffit de donner le nom
du tableau, suivi de l’indice de l’élément entre crochets :

Les types dérivés

Nom_du_Tableau [indice]
○ Où indice est une expression entière positive ou nulle.
○ Un indice est toujours positif ou nul ;
○ L’indice du premier élément du tableau est 0 ;
○ L’indice du dernier élément du tableau est égal au nombre
d’éléments – 1.
 Exemples :
○ int A[5] = {12 , 23 , 34 , 45 , 56}; // A[0] = 12 ; A[1] = 23 ; A[2] = 34 ;
// A[3] = 45 ; A[4] = 56 ;
○ for( i = 0 ; i< 5 ; i++ ) //Affichage des éléments

printf(‘’A[%d] = %d \t‘’,i,A[i]); // du tableau A

23/12/2020 Programmer en langage C 22

Les tableaux

 Les tableaux à une dimensions

 Remarque
○ Chaque élément ( TAB[i] ) d’un tableau ( int TAB[20] ) est

Les types dérivés

manipulé comme une simple variable, on peut :
 la lire : scanf("%d", &TAB[i] ); // TAB[i] sera initialisé par un
// entier saisi depuis la clavier
 l’écrire : printf("TAB[%d] = %d", i , TAB[i] ); //Le contenu de TAB[i]
//sera affiché sur écran

○ Pour initialiser un tableau (TAB1) par les éléments d’un autre

tableau (TAB2) : évitez d’écrire TAB1 = TAB2 (incorrect)
○ On peut par exemple écrire :
for( i = 0 ; i < taille_tableau ; i++ )
TAB1[i] = TAB2[i];
○

23/12/2020 Programmer en langage C 23

Les tableaux 2D
 Les tableaux à deux dimensions

 Un tableau à deux dimensions se déclare donc de la

Les types dérivés

manière suivante :

int Nom_tableau [10][20];

 En faisant le rapprochement avec les mathématiques,

on peut dire que mat est une matrice de 10 lignes et
de 20 colonnes.

23/12/2020 Programmer en langage C 24

Les tableaux 2D
 Les tableaux à deux dimensions
 On accède à un élément du tableau par l’expression T[i][j].
 Pour initialiser un tableau à plusieurs dimensions à la
compilation, on utilise une liste dont chaque élément est une

Les types dérivés

liste de constantes :
#include <stdio.h>
#define L 3 //nombre de lignes
#define C 2 //nombre de colonnes
int tab[L][C] = {{1, 2}, {14, 15}, {100, 200}};
main() {
int i, j;
for (i = 0 ; i < L; i++) {
for (j = 0; j < C; j++)
printf("tab[%d][%d]=%d\n",i,j,tab[i][j]); }
}
23/12/2020 Programmer en langage C 25
23/12/2020 Programmer en langage C 26
Définition

 Une fonction est un bloc de code C indépendant,

référencé par un nom, qui réalise une tâche précise et qui
peut renvoyer une valeur au programme qui l’a appelée :

Les fonctions
 Une fonction est référencée par un nom: ce nom est
unique.
 Une fonction peut être appelée par une autre fonction.

23/12/2020 Programmer en langage C 27

Définition : Syntaxe

type identificateur ( liste de-déclarations-de-paramètres )

{
liste-de-déclarations (optionnel)

Les fonctions
liste-d'instructions
}

23/12/2020 Programmer en langage C 28

Définition : Sémantique
 type :est le type de la valeur rendue par la fonction ;
 identificateur :est le nom de la fonction ;
 Liste de déclarations-de-paramètres : est la liste
(séparés par des virgules) des déclarations des

Les fonctions
paramètres formels.
 La liste-de-déclarationsoption : permet si besoin, de
déclarer des variables qui seront locales à la fonction,
elles seront donc inaccessibles de l'extérieur.
 La liste-d'instructions: est l'ensemble des instructions
qui seront exécutées sur appel de la fonction. Parmi
ces instructions, il doit y avoir au moins une
instruction du type : return expression ;

23/12/2020 Programmer en langage C 29

Exemple de définition et d’utilisation d’une fonction en C

/*************** la fonction equation ****************/

Les fonctions
float equation (float x, int b, int c)
{
float val ; /* déclaration d’une variable "locale"

val = x * x + b * x + c ;
return val ;

23/12/2020 Programmer en langage C 30

Exemple de définition et d’utilisation d’une fonction en C
#include <stdio.h>
/***** le programme principal (fonction main) *****/
main(){
/* déclaration de fonction fexple */
float equation (float, int, int) ;

Les fonctions
float x = 1.5 ;
float y, z ;
int n = 3, p = 5, q = 10 ;
/* appel equation avec les arguments x, n et p */
y = equation(x, n, p) ;
printf ("valeur de y : %f ", y) ;
/* appel equation avec les arguments x+0.5, q et n-1 */
z = equation(x+0.5, q, n-1) ;
printf ("valeur de z : %f ", z) ;
}

23/12/2020 Programmer en langage C 31

Exemple de définition et d’utilisation d’une fonction en C

/* définition de la fonction */

long cube(long x) /* en-tête de la fonction cube*/

Les fonctions
{
long x_cube; /* variable “locale” à la fonction cube */

x_cube= x*x*x;
return x_cube;
}

23/12/2020 Programmer en langage C 32