ROYAUME DU MAROC

OFPPT

Office de la Formation Professionnelle et de la Promotion du Travail

DIRECTION RECHERCHE ET INGÉNIERIE DE FORMATION

RÉSUMÉ THÉORIQUE
&
GUIDE DE TRAVAUX PRATIQUES

LANGAGE DE PROGRAMMATION
MODULE N° 10 :
STRUCTUREE

SECTEUR : NTIC

SPÉCIALITÉ : TDI / TRI

NIVEAU : TS

Document élaboré par :

0
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

RAHMANI Abdelhak - Formateur Animateur au CDC

Tertiaire – TIC - AV - AG - DRIF

OFPPT/DRIF 1
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

SOMMAIRE

Page
A- Introduction aux Langages de 2
programmation……………………………..
B- Premier programme en C…………………………………………………… 3
C- La syntaxe du Langage C…………………………………………………… 6
1) Les Types de données de 6
C……………………………………………………
2) Déclaration et stockage de variables, 7
constantes………………………….
3) Les fonctions d’entrée/sortie les plus utilisées en 8
C……………………….
4) Expressions, Opérateurs (arithmétiques, relationnels, affectations…)… 12
- Exercices d’application………………………………………………………………….. 16
- Corrigés……………………………………………………………………………………. 17
5) Structures de contrôle  «  Boucles et 18
Conditions  »…………………………
 Structures 18
itératives……………………………………………………………...
 Structures alternatives………………………………………………………….. 21
- Exercices d’application…………………………………………………………….. 23
- 24
Corrigés…………………………………………………………………………….....
6) Structures de données 32
avancées……………………………………………...
 Tableaux et matrices……………………………………………………………. 32
- Exercices d’application…………………………………………………………….. 33
- Corrigés………………………………………………………………………………. 36
 Pointeurs (Allocation dynamique de la mémoire)….……………………….. 39
 43
Structures………………………………………………………………………….
- Exercices d’application…………………………………………………………….. 44
- Corrigés………………………………………………………………………………. 44
7) Fonctions……………………………………………………………………….. 50
- Exercices d’application…………………………………………………………….. 52
- Corrigés………………………………………………………………………………. 52
8) Les fichiers de données……………………………………………………….. 57
- Exercices d’application…………………………………………………………….. 63
- Corrigés………………………………………………………………………………. 63
Références bibliographiques……………………………….............................. 65

OFPPT/DRIF 2
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

A- Introduction aux Langages de programmation

L’ordinateur est une machine non intelligente, qui sait exécuter des opérations très
simples :

 Opérations arithmétiques : addition, soustraction, multiplication…

 Opérations de comparaisons.
 Lecture de valeurs et affichage de résultats.

Se pose alors la question très simple : où réside l’importance de l’ordinateur ? La

réponse est qu’il peut être programmé : c'est-à-dire qu’on peut lui donner, à l’avance,
la séquence (suite ordonnée) des instructions (ordres) à effectuer l’une après l’autre. La
grande puissance de l’ordinateur est sa rapidité. Mais, c’est à l’homme
(programmeur) de tout faire et de tout prévoir, l’ordinateur ne fait qu’exécuter des
ordres codés en binaire (langage machine). C’est pour cela que des langages dits
« évolués » ont été mis au point pour faciliter la programmation, exemples :
FORTRAN, COBOL, BASIC, PASCAL…et bien évidemment, le langage C qui
favorise (tout comme le Pascal) une approche méthodique et disciplinée, on parle de
méthode « structurée », ce langage a vu le jour dans les Laboratoires BELL en 1978,
et il a été crée par KERNIGHAM et RITCHIE pour développer le système
d’exploitation UNIX.

Le C est un langage compilé, c'est-à-dire qu’il faut passer par les étapes suivantes :
1. Entrer le programme ou le code source dans l’ordinateur à l’aide d’un
EDITEUR (DEV C++ par exemple qui est disponible gratuitement sur
Internet).
2. Traduire ce programme en langage machine (codes binaires compréhensibles
par l’ordinateur), c’est la compilation.
3. Exécuter le programme et visualiser le résultat.

OFPPT/DRIF 3
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

B- Premier programme en C
Remarque :
Tous les programmes ont été écrits à l’aide de l’éditeur (ou plutôt EDI Environnement
de Développement Intégré) DEV C++ (ver 4.9.9.2) qui est téléchargeable gratuitement
de l’Internet (www.bloodshed.net/dev/devcpp.html), la taille du fichier < 9 Mo.
Une fois installée sur votre ordinateur, vous pouvez lancer l’application DEV C++, à
partir du bouton Démarrer, Programmes, Bloodshed Dev C++ et enfin DEV C++
pour obtenir l’interface suivante :

Pour écrire votre premier programme en C, vous choisissez le menu Fichier,

Nouveau ; Fichier Source, vous obtenez :

Tapez au clavier les instructions suivantes :

OFPPT/DRIF 4
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

#include<stdio.h>
#include<stdlib.h>
int main()
{
// Ceci est un commentaire
// Déclaration de la variable entière a
int a;
// Affectation de la valeur 10 à la variable a
a=10;
// Affichage de la variable a
printf("%d\n",a);
// Affichage d'un texte
printf("Fin du travail\n");
system("pause");
return 0;
}

A présent, il est temps d’enregistrer le fichier source (code) à l’aide du menu Fichier,

ensuite Sauvegarder (ou plus simplement le bouton ou encore CTRL S), nommez-
le exemple1 (et choisissez l’emplacement en parcourant l’arborescence de votre
disque).

Maintenant, vous devez compiler votre programme à l’aide du bouton  de la barre

d’outils (ou CTRL F9). Si tout se passe bien, c’est à dire pas d’erreurs, vous obtenez :

Dernière étape, il ne vous reste plus qu’à exécuter votre programme ; à l’aide du

bouton de la barre d’outils (ou CTRL F10) :

OFPPT/DRIF 5
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Commentaires :
1- Dans le programme précédent, il y a des directives du style : #include permettant
d’inclure les bibliothèques, c'est-à-dire, les fichiers déclarant les fonctions standard,
par exemple :
- stdio (STanDard Input Output) : qui fait le lien entre le programme et la console
(clavier/écran). Dans notre cas, c’est la fonction printf (affichage à l’écran).
- stdlib : qui permet, entre autre, la gestion dynamique de la mémoire (malloc et free -
voir plus loin).
2- La fonction principale du programme appelée « main » qui représente le point
d’entrée du programme où débutera son exécution.
3- Le bloc d’instructions délimité par les accolades { … } et comportant :
- Des commentaires : // …commentaire ou /* commentaire */.
- Des déclarations de variables : dans notre cas, a est une variable entière. Une variable
représente une case mémoire au niveau de la RAM de l’ordinateur que l’on se réserve
pour notre programme.
- Chaque instruction se termine par ;
- Des affectations, dans notre cas : a = 10 ; signifie que la valeur 10 est stockée (en
mémoire) au niveau de la variable a.
- Des affichages de variables ou de texte au niveau de la console à l’aide de printf. Le
\n signifie que l’on retourne à la ligne après affichage.
- La dernière instruction : system(pause) ; qui à l’origine est une commande du MS-
DOS/Windows (pause) permettant l’affichage du message « Appuyez sur une touche
pour continuer » et met le système en attente de la frappe d’une touche du clavier,
sinon, la console d’exécution se ferme automatiquement à la fin de l’exécution d’un
programme ne laissant guère le temps de visualiser les éventuels résultats affichés.
Cette dernière instruction peut être remplacée par getch() ; invitant l’utilisateur à tapez
une touche et mettant ainsi la console en attente !

OFPPT/DRIF 6
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

C- Syntaxe du Langage C
1) Les Types de données de C
Les variables existantes en C sont de 2 types : scalaires (entiers, réels, caractères) et
agrégés (combinaison de scalaires, comme les tableaux, les matrices…).
Variable de type scalaire :
C’est une variable ne contenant qu’une seule valeur sur laquelle on peut faire un calcul
arithmétique. Il existe 3 types de base : char, int et float.
Une variable de type char est codée sur 1 octet (8 bits).
Une variable de type int ou short int est codée sur 16 bits et long int sur 32 bits.
Une variable de type float représente un réel flottant, c'est-à-dire un nombre stocké en
deux parties, une mantisse et un exposant. La taille de la mantisse définit le nombre de
chiffres significatifs, alors que la taille de l'exposant définit le plus grand nombre
acceptable par la machine. Float est codé sur 32 bits et il existe le réel double précision
de type double codé sur 64 bits.
En résumé :

Taille (en bits) Plage de valeurs

Type
char 8 -128 à +127
short (short int) 16 -32768 à 32767
long (long int) 32 -2.147.483.648 à 2.147.483.647
float 32 -3.4e38 à 3.4e38 (7 chiffres significatifs)
double (long float) 64 -1.7e308 à 1.7e308 (15 chiffres significatifs)

Les conversions :
- D’abord implicites, c'est-à-dire automatiques et toujours de la plus petite à la plus
grande précision :
short int  int  long int
float  double  long double
- Ensuite explicites, par exemple :
int a ; float b ;
On convertie à l’aide de : (float)a ou float(a) et (int)b ou int(b)

OFPPT/DRIF 7
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

2) Déclaration et stockage de variables, constantes…

Une variable doit être définie, dans un programme, par une déclaration : on indique le
nom que l'on désire lui donner, son type (int, float, char...) pour que le compilateur
sache quelle taille en mémoire il doit lui réserver et les opérateurs qui peuvent lui être
associés, mais aussi comment elle doit être gérée (visibilité, durée de vie,...).
Les constantes
Exemple : #define PI 3.14 ou const float pi=3.14;
#include <stdio.h>
#include <stdlib.h>
#define PI 3.14 /* PI est une constante=3,14 */
// on peut aussi utiliser : const float PI=3.14;
int main ()
{
float P,R;
printf("Entrez la valeur du rayon : ");
scanf("%f", &R);
P=2*PI*R;
printf("Le perimetre du cerle est : %f\n",P);
printf("Fin du travail\n");
system("pause");
return 0;
}

La Déclaration de variables simples

Exemple :
int i ; /* la variable i est déclarée comme étant entière */
int compteur = 0 ; /* on déclare et on initialise la variable */
float x, y ;
double VOLUME ; /* Attention, le C fait la différence entre minuscule et majuscule */
char touche_clavier ;

Déclarations locales
Dans tout bloc d'instructions {…}, avant la première instruction, on peut déclarer des
variables. Elles seront alors "locales au bloc d’instructions" : elles n'existent qu'à
l'intérieur du bloc (on parle alors de la portée de ces variables qui est limitée au bloc
ainsi que de la durée de vie de ces mêmes variables qui sont en fait créées à l’entrée
du bloc et libérées à sa sortie).

OFPPT/DRIF 8
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Déclarations globales
Une déclaration faite à l'extérieur d'un bloc d'instructions {…}, (en général en début
du fichier) est dite globale. La variable est stockée en mémoire statique, sa durée de
vie est celle du programme. Elle est visible de sa déclaration jusqu'à la fin du fichier.

Déclaration de type
De nouveaux types de variables peuvent être déclarés à l’aide de typedef. Cela permet
de donner un nom à un type donné, mais ne crée aucune variable.
Exemple :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
typedef float prix;
typedef float quantite;
typedef float total;
prix a, b;
quantite x, y;
total z, t;
printf("Entrez les prix a et b : ");
scanf("%f %f", &a, &b);
printf("Entrez les quantites x et y : ");
scanf("%f %f", &x, &y);
z = a * x;
t= b * y;
printf("Le total1 est : %f et Le total2 est : %f\n", z, t);
printf("Fin du travail\n");
system("pause");
return 0;
}

3) Les fonctions d’entrée/sortie les plus utilisées en C

Comme le langage C a été crée pour être indépendant du matériel sur lequel il est
implanté, les entrées sorties, bien que nécessaires à tout programme, ne font pas partie
intégrante du langage, c’est pour cela qu’on fait appel à des bibliothèques de
fonctions de base, standardisées au niveau des compilateurs. En voici les bibliothèques
principales :
 Entrée et sortie de données : <stdio.h>

OFPPT/DRIF 9
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

 Traitement de chaînes de caractères : <string.h>

 Fonctions d'aide générales - gestion de la mémoire : <stdlib.h>
 Fonctions arithmétiques : <math.h> …
Comme on vient de voir, la bibliothèque standard <stdio.h> contient un ensemble de
fonctions qui assurent la communication entre l’ordinateur et l’extérieur. En voici les plus
importantes :
printf()
La fonction printf est utilisée pour afficher ou transférer du texte, ou des valeurs de
variables vers le fichier de sortie standard stdout (par défaut l'écran).
Exemple1 :
Ecrivez la suite d'instructions dans un fichier source « exemple1 » :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int a = 2;
int b = 4;
printf("%d fois %d est %d\n", a, b, a*b);
printf("Fin du travail\n");
system("pause");
return 0;
}

Exemple2 :
Taper dans un fichier source « exemple2 » le code ci-dessous, constatez que les
numéros de lignes ont été affichés ! (Outils, Options de l’Editeur et Affichage…) :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
float x = 10.1234;
double y = 20.1234567;
printf("%f\n", x);
printf("%f\n", y);
printf("%e\n", x);
printf("%e\n", y);
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 10
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

En Résumé, voici les spécificateurs de format de printf :

SYMBOLE TYPE IMPRESSION COMME
%d ou %i int entier relatif
%u int entier naturel (unsigned)
%c int caractère
%x int Entier en notation hexadécimale
%f double rationnel en notation décimale
%e ou %E double rationnel en notation scientifique (exponentielle)
%s char* chaîne de caractères

scanf()

La fonction scanf est la fonction symétrique à printf, mais au lieu d’afficher, elle
permet de lire des variables; elle fonctionne pratiquement comme printf, mais en sens
inverse. Cette fonction reçoit des données à partir du fichier d’entrée standard stdin (le
clavier par défaut), ces données sont mémorisées aux adresses indiquées par &.
Exemple1 :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int jour, mois, annee;
scanf("%d %d %d", &jour, &mois, &annee);
printf("le jour est: %d le mois est: %d l'annee est: %d\n", jour, mois, annee);
printf("Fin du travail\n");
system("pause");
return 0;
}
A l’exécution:

Exemple2 :

#include<stdio.h>

OFPPT/DRIF 11
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

#include<stdlib.h>
int main()
{
int occ=0, elem;
printf("Donner deux valeurs : ");
scanf("%d",&elem);
printf("première valeur est : %d\n",elem);
scanf("%d",&elem);
printf("deuxième valeur est : %d\n",elem);
printf("Fin du travail\n");
system("pause");
return 0 ;
}

A l’exécution::

putchar()
La commande putchar ('a') affiche le caractère « a » à l’écran (stdout), l’argument de
cette fonction est bien évidemment un caractère.
Exemple :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
char a = 225;
char b = 'e';
putchar('x'); /* afficher la lettre x */
putchar('\n'); /* retour à la ligne */
putchar('?'); /* afficher le symbole ? */
putchar('\n');
putchar(65); /* afficher le symbole avec */
/* le code 65 (ASCII: 'A') */
putchar('\n');
putchar(a); /* afficher la lettre avec */
/* le code 225 (ASCII: 'ß') */
putchar('\n');
putchar(b); /* affiche le contenu de la var b 'e' */
putchar('\n');
printf("\nFin du travail\n"); /* 2 retours à la ligne! */
system("pause");
return 0;
}

OFPPT/DRIF 12
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

getchar() - puts(chaîne) et gets(chaîne)

- La fonction getchar, plus utilisée que putchar, permet de lire le prochain caractère du
fichier d’entrée standard stdin.
- La fonction puts(chaîne) affiche, à l’écran, la chaîne de caractères « chaîne » puis
positionne le curseur en début de ligne suivante.
- La fonction gets(chaîne) lecture d'une chaîne sur stdin. Tous les caractères peuvent
être entrés, y compris les blancs. La saisie est terminée par un retour chariot.
Exemple :
#include <stdio.h>
#include <stdlib.h>
int main ()
{ char a ;
char TEXTE[] = "Voici une premiere ligne.";
puts(TEXTE);
puts("Voici une deuxieme ligne.");
printf("Tapez un texte\n");
gets(TEXTE);
puts(TEXTE);
//printf("Tapez un caractere\n");
a = getchar();
putchar(a);
putchar('\n');
printf("Fin du travail\n");
system("pause");
return 0;
}

4) Expressions, Opérateurs (arithmétiques, relationnels, affectations…)

Affectation
On sait faire déjà : variable = expression ;
Exemple : i = 3 ; c = ’z’ ;
Affectations multiples : a = b = c = 0 ;
Il existe en C une manière optimale d’affectation ne faisant évaluer la variable qu’une
seule fois, par exemple : i = i+1 (2 fois !) peut s’écrire i+ = 1 (une seule fois).
Exemple :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i;
i=4;

OFPPT/DRIF 13
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

i+=1;
printf("i = %d\n",i);
i-=1;
printf("i = %d\n",i);
i*=2;
printf("i = %d\n",i);
i++; // très utile dans les boucles for
printf("i = %d\n",i);
i--;
printf("i = %d\n",i);
printf("Fin du travail\n");
system("pause");
return 0;
}

Voici en résumé :
Les pré incrémentations - décrémentations :
++i  i+=1  i = i+1
--i  i-=1  i = i-1
Dans ces cas, la valeur de l’expression est la valeur de la variable après l’opération.
Les post incrémentations - décrémentations :
i++  i+=1  i = i+1
i--  i-=1  i = i-1
Dans ces cas, la valeur de l’expression est la valeur de la variable avant l’opération.
Expressions
Une expression est un calcul qui donne une valeur résultat.
Exemple : 2 + 4.
Une expression comporte des variables, des appels de fonction et des constantes
combinés entre eux par des opérateurs.
Exemple : Ma_Valeur*cos(Mes_Angle*PI/90)).
Pour former une expression, les opérateurs possibles sont très nombreux :
Opérateurs arithmétiques
Ces opérateurs s’appliquent à des valeurs entières ou réelles. Ces opérateurs sont :
+ (addition), - (soustraction), * (produit), / (division), % (reste de la division).

Opérateurs relationnels

OFPPT/DRIF 14
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Comparaisons :
Ces opérateurs sont : = = (égalité), != (différent), <, >, <=, >=. Des deux côtés du
signe opératoire, il faut deux opérandes de même type (sinon, transformation
implicite). Attention, le compilateur ne prévient pas on met = (affectation) au lieu de
= =  !!!
Logique booléenne
Le résultat est toujours 0 (faux) ou 1 (vrai).
Ces opérateurs sont : && (ET), || (OU) et ! (NON). (on verra l’utilisation plus loin).
Voici le tableau des priorités :
Priorité 1 (la plus forte):  () 
Priorité 2:  ! ++ -- 
Priorité 3:  * / % 
Priorité 4:  + - 
Priorité 5:  < <= > >= 
Priorité 6:  == != 
Priorité 7:  && 
Priorité 8:  || 
Priorité 9 (la plus faible):  = += -= *= /= %= 
Exemple : « Résolution de l’équation du 1er degré : ax + b = 0 »
#include <stdio.h>
#include <stdlib.h>
int main ()
{
float a, b, x;
printf("Entrez les valeurs de a et b : ");
scanf("%f %f",&a,&b);
if (a!= 0) {
x=-b/a;
printf("le resultat est : %f\n",x);
}
else
if (b==0) printf("Tout reel est solution\n");
else printf("Pas de solution\n");
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 15
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Fonctions mathématiques standard

Ces fonctions sont prédéfinies dans la bibliothèque standard <math.h>, un programme
faisant appel à ces fonctions doit contenir la ligne : #include <math.h>
En voici la liste :
Commande C Explication
exp(X) fonction exponentielle
log(X) logarithme naturel
log10(X) logarithme à base 10
pow(X,Y) X exposant Y
sqrt(X) racine carrée de X
fabs(X) valeur absolue de X
floor(X) arrondir en moins
ceil(X) arrondir en plus
fmod(X,Y) reste rationnel de X/Y (même signe que X)
sin(X) cos(X) tan(X) sinus, cosinus, tangente de X
asin(X) acos(X) atan(X) arcsin(X), arccos(X), arctan(X)
sinh(X) cosh(X) tanh(X) sinus, cosinus, tangente hyperboliques de X

Exemple1 :
Tapez le programme suivant :
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
{
double A, B, RES;
/* Saisie de A et B */
printf("Introduire la valeur pour A : ");
scanf("%lf", &A);
printf("Introduire la valeur pour B : ");
scanf("%lf", &B);
RES = A*A;
/* Affichage du résultat */
printf("Le carré de A est %f \n", RES);
/* Calcul */
RES = B*B;
/* Affichage du résultat */
printf("Le carré de B est %f \n", RES);
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 16
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exemple2 :
Modifiez le programme précédent de façon à ce qu'il affiche :
- AB (A à la puissance B),
- L'hypoténuse d'un triangle rectangle de côtés A et B,
- La tangente de A en n'utilisant que les fonctions sin et cos,
- La valeur arrondie (en moins) de A/B,
- La valeur arrondie (en moins) à trois positions derrière la virgule de A/B.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main ()
{
double A, B, RES;
printf("Introduire les valeurs de A et B : ");
scanf("%lf %lf", &A, &B);
RES = pow(A,B);
printf("A exposant B est %e \n", RES); // pour l'affichage decimal : %f
RES = sqrt(pow(A,2)+pow(B,2));
printf("hypotenuse du triangle rectangle est %f \n", RES);
RES = sin(A)/cos(A);
printf("La tangente de A est %f \n", RES);
RES = floor(A/B);
printf("La valeur arrondie en moins de A/B est %f \n", RES);
printf("Fin du travail\n");
system("pause");
return 0;
}

Exercices
Exercice 1

Quels sont les résultats fournis le programme suivant :

#include<stdio.h>
#include<stdlib.h>
int main()
{
char c;
int n;
c='s';
printf("cas A : %c\n",c);
n=c;
printf("cas B : %c\n", n);
printf("cas C : %d %d\n", c, n);
printf("cas D : %x %x\n", c, n);
system("pause");
return 0;
}

OFPPT/DRIF 17
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 2

Quels sont les résultats fournis le programme suivant :

#include<stdio.h>
#include<stdlib.h>
int main()
{
int i,j,n;
i=0;
n=i++;
printf("A : i =%d n = %d\n", i,n);
i=10; n=++i;
printf("B : i =%d n = %d \n", i, n);
i=20; j =5; n = i++*++j;
printf("C : i = %d j = %d n = %d \n", i, j, n);
i=15 ;
n=i+=3;
printf("D : i = %d n = %d\n", i, n);
i=3;
j=5;
n=i*=--j;
printf("E : i = %d j = %d n = %d\n", i, n);
system("pause");
return 0;
}

Exercice 3

Ecrire un programme en C qui calcule le volume d’une sphère étant donné son rayon,
sachant que V = 4/3(R3).
Exercice 4
Ecrire un programme en C qui convertit les degrés Fahrenheit en degrés Celsius selon
la formule : TC = 5/9(TF – 32).

Corrigés
Exercice 1

Exercice 2

OFPPT/DRIF 18
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 3
#include<stdio.h>
#include<stdlib.h>
#include<math.h> //on rajoute la bibliothèque math pour la foncyion pow
const float PI=3.14;
int main()
{
float R,V;
printf("Entrez le rayon de la sphere : ");
scanf("%f",&R);
V=(4.0/3.0)*PI*pow(R,3);//pow(R,3) = R*R*R
printf("Le volume de la sphere est : %.2f\n",V);
system("pause");
return 0;
}

Exercice 4
#include<stdio.h>
#include<stdlib.h>
const float PI=3.14;
int main()
{
float TC,TF;
printf("Entrez la temperature en degre Fahrenheit : ");
scanf("%f",&TF);
TC=(5.0/9.0)*(TF-32);
printf("la temperature en degre Celsius est : %.2f\n",TC);
system("pause");
return 0;
}

5) Structures de contrôle
Boucles ou structures répétitives

OFPPT/DRIF 19
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Les boucles sont très importantes en programmation puisqu’elles permettent de répéter

plusieurs fois un bloc d'instructions, et c’est ainsi que l’ordinateur révèle toute sa
puissance et sa rapidité.
Il existe, en C, 3 types de boucles :
1- Boucle for (pour)
Cette boucle est utile quand on connaît à l’avance le nombre d’itérations à effectuer.
Sa structure est la suivante :
for (expression initiale; expr_condition; expr_incrémentation) instruction
Exemple1 :
Ecrivez un programme qui affiche les nombres de 1 à 10 :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i;
for (i=1; i<=10; i++) // i++ ou i=i+1
{ // { : est facultative comme il n'y a qu'une seule instruction!
printf("%d ",i);
}
printf("\nFin du travail\n");
system("pause");
return 0;
}

Modifiez le programme précédent pour qu’il affiche les chiffres à la verticale.

2- While (tant que)
while (expression) instruction ;
Tant que l'expression ou la condition est vraie (!=0), on effectue l'instruction, soit une
seule instruction (terminée par ;), soit un bloc d’instructions (entre {}). La condition
est au moins évaluée une fois. Tant qu'elle est vraie, on effectue l'instruction, dès
qu'elle est fausse, on passe à l'instruction suivante (si elle est fausse dès le début,
l'instruction n'est jamais effectuée, on ne rentre jamais dans la boucle).

Exemple :
Ecrivez un programme qui permet de saisir un entier N au clavier et qui calcule et
affiche la somme : S = 1 + 2 + … + N.

OFPPT/DRIF 20
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

#include <stdio.h>
#include <stdlib.h>
int main ()
{
int N, S, i=1;
printf("Saisir le nombre N : ");
scanf("%d",&N);
S=0;
while (i<=N)
{
S=S+i;
i++;
}
printf("La somme S = %d\n",S);
printf("Fin du travail\n");
system("pause");
return 0;
}

3- Do While (faire tant que)

do instruction while (expression) ;
Cette structure est comme le while, mais à la différence fondamentale que l'instruction
est au moins faite une fois ; Attention!!!
Exemple1 :
Ecrivez un programme qui permet de saisir un entier N au clavier et qui calcule et
affiche la factorielle N (N !) : produit : P = 1 x 2 x … x N.
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int N, P, i=1;
printf("Saisir le nombre N : ");
scanf("%d",&N);
P=1;
do
{
P=P*i;
i++;
} while (i<=N);
printf("Le factoriel N est = %d\n",P);
printf("Fin du travail\n");
system("pause");
return 0;
}

Exemple2 :

OFPPT/DRIF 21
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Tapez le programme suivant :

#include <stdio.h>
#include <stdlib.h>
int main ()
{
int a;
do
{
puts("veuillez entrer le nombre 2009");
scanf("%d",&a);
}
while (a!=2009);
puts("c'est gentil de m'avoir obei");
printf("Fin du travail\n");
system("pause");
return 0;
}

Exercice récapitulatif sur les boucles :

Ecrivez un programme en C qui lit N valeurs « réelles » saisies au clavier et qui
calcule et affiche la somme S et la moyenne M de ces valeurs.
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i,N;
float S,M,V;
S=0;
printf("entrez le nombre de valeurs N : ");
scanf("%d",&N);
printf("entrez le N valeurs : ");
for (i=1;i<=N;i++)
{
scanf("%f",&V);
S=S+V;
}
M=S/N;
printf("la somme des N valeurs est S = %f\n",S);
printf("la moyenne des N valeurs est M = %f\n",M);
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 22
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Structures alternatives
On a souvent besoin de n'effectuer certaines instructions que si des conditions sont
remplies. On dispose pour cela du IF et du SWITCH.
1- If - Else (Si - Sinon)
if (expression) instruction ; l’instruction peut être simple ou un bloc {…}.
if (expression) instruction1 else instruction2 ;
Exemple1 :
Ecrivez un programme en C qui saisi (ou lit) 2 valeurs au clavier, les compare et
affiche la plus grande valeur.
#include <stdio.h>
#include <stdlib.h>
int main ()
{
float A,B,MAX;
printf("Entrez les 2 valeurs A et B : ");
scanf("%f %f",&A,&B);
if (A>B) MAX = A;
else MAX = B;
printf("La plus grande des 2 valeurs est : %f\n",MAX);
printf("Fin du travail\n");
system("pause");
return 0;
}

Exemple2 :
Ecrivez un programme qui lit 2 valeurs A et B, les échange si A > B de manière à les
afficher dans l’ordre croissant.

#include <stdio.h>
#include <stdlib.h>
int main ()
{
float A,B,AUX;
printf("Entrez les 2 valeurs A et B : ");
scanf("%f %f",&A,&B);
if (A>B)
{
AUX=B;

OFPPT/DRIF 23
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

B=A;
A=AUX; // Echange de A et B
}
printf("La valeurs triees : %f %f\n",A,B);
printf("Fin du travail\n");
system("pause");
return 0;
}

2- Switch - Case (brancher - dans le cas)

switch (expression_entière)
{
case cste1:instructions
case cste2:instructions
........
case csteN:instructions
default :instructions
}
Exemple1 :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int a;
printf("Entrez la valeur de a : ");
scanf("%d",&a);
switch(a)
{
case 1:printf("a vaut un\n");
break;
case 2:printf("a vaut deux\n");
break;
case 3:printf("a vaut trois\n");
break;
default:printf("a non compris entre 1 et 3\n");
break;
}
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 24
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exemple 2 :
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
float NOTE;
int note;

printf("Quelle note as-tu obtenu /20: ");

scanf("%f", &NOTE);
note=int(floor(NOTE/4));

switch(note)
{
/* si note == 0 */
case 0:
puts("Nul");
break;

/* si note == 1 */
case 1:
puts("faible");
break;

/* si note == 2 */
case 2:
puts("Insuffisant");
break;

/* si note == 3 */
case 3:
puts("Assez bien");
break;

/* si note == 4*/
case 4:
puts("Bien");
break;

/* si note == 5 */
case 5:
puts("Excellent !");
break;

/* si note est différente de 0, 1, 2, 3, 4 et 5 */

default:
puts("Tu dois saisir une note entre 0 et 20.");
break;
}
printf("Fin du travail\n");
system("pause");

OFPPT/DRIF 25
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

return 0;
}
A l’exécution::

Exercices
Exercice 5 « Structures conditionnelles »

Ecrire un programme en C qui demande deux nombres à l’utilisateur et l’informe

ensuite si leur produit est négatif ou positif (sans calculer le produit des deux
nombres).

Exercice 6 « nombre inconnu de données »

Les données à traiter sont constituées par une suite de nombres entiers tapés au clavier. Chaque
nombre est séparé du précédent par au moins un blanc (ou un retour). Pour indiquer la fin de la
suite, on met la valeur 999 (et on impose que tous les nombres de la suite soient différents de
999).
Les résultats indiqués seront valables pour les données : 12 -4 6 4 6 999
Attention : on peut donner une « suite vide» en tapant seulement 999. Vérifier ce que deviennent
vos solutions dans ce cas particulier.
A1. Lire les données et afficher le nombre total de valeurs de la suite. Résultat : 5
A2. Lire les données et afficher la somme des valeurs lues. Résultat : 24
A3. Lire les données et afficher le minimum. Résultat : -4
A4. Lire les données et afficher la somme des valeurs strictement positives. Résultat : 28
A5. Lire les données et afficher le minimum des valeurs strictement positives. Résultat : 4

Exercice 7 « nombre inconnu de données »

Les données à traiter sont encore constituées par une suite de nombres entiers tapés au clavier.
Chaque nombre est séparé du précédent par au moins un blanc (ou un retour). Mais, cette fois, on
met devant la suite une valeur qui indique le nombre de valeurs de la suite.
Les résultats indiqués seront valables pour les données : 5 12 -4 6 4 6
Attention : on peut donner une « suite vide » en tapant seulement 0. Vérifier ce que deviennent
vos solutions dans ce cas particulier.
B1. Lire les données et afficher la somme des valeurs lues. Résultat : 24
B2. Lire les données et afficher le minimum. Résultat : -4
B3. Lire les données et afficher la somme des valeurs strictement positives. Résultat : 28
B4. Lire les données et afficher la moyenne des valeurs strictement positives. Résultat : 7.00
Note : comparer soigneusement les solutions A2 et B1, A3 et B2, A4 et B3.

Exercice 8
Ecrire un programme en C qui affiche la table de Pythagore de la multiplication :

OFPPT/DRIF 26
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 9
Ecrire un programme en C qui permet d’afficher :
**********
*********
********
*******
******
*****
****
***
**
*

Exercice 10

Ecrire un programme en C qui détermine la nème valeur U n de la suite suivante :

U1 = 1
U2 = 1
Un = Un-1 + Un-2

Corrigés

OFPPT/DRIF 27
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 5
1ère Solution « longue » :

#include<stdio.h>
#include<stdlib.h>
int main()
{
int a,b;
printf("Entrez 2 entiers :");
scanf("%d %d",&a,&b);
if ((a>0) && (b>0))
printf("Les 2 nombres sont de meme signe\n");
else
if ((a>0) && (b<0))
printf("Les 2 nombres sont de signes contraires\n");
else
if ((a<0) && (b>0))
printf("Les 2 nombres sont de signes contraires\n");
else
printf("Les 2 nombres sont de meme signe\n");
system("pause");
return 0;
}

2ème Solution « courte » :

#include<stdio.h>
#include<stdlib.h>
int main()
{
int a,b;
printf("Entrez 2 entiers :");
scanf("%d %d",&a,&b);
if (((a>0) && (b>0)) || ((a<0) && (b<0)))
printf("Les 2 nombres sont de meme signe\n");
else
printf("Les 2 nombres sont de signes contraires\n");
system("pause");
return 0;
}

Exercice 6
A1
// Exercice A1
// Affichage du nombre de valeurs de la suite terminée par 999
#include<stdio.h>
#include<stdlib.h>
int main()
{
int occ=0, elem;
printf("Donner les valeurs de la suite 999 pour finir : ");
scanf("%d",&elem);
if (elem==999) printf("Liste vide\n");

OFPPT/DRIF 28
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

else {
while (elem!=999)
{ occ++;
scanf("%d",&elem);
}
}
printf("Le nombre d'éléments de la suite est : %d\n",occ);
printf("Fin du travail\n");
system("pause");
return 0 ;
}

A2
// Exercice A2
// Affichage de la somme des valeurs de la suite terminée par 999
#include<stdio.h>
#include<stdlib.h>
int main()
{
int somme=0, elem ;
printf("Donner les valeurs de la suite 999 pour finir : ");
scanf("%d",&elem);
if (elem==999) printf("Liste vide\n");
else
while (elem!=999)
{ somme= somme+elem ;
scanf("%d",&elem);
}
printf("La somme des elets de la suite est : %d\n",somme);
printf("Fin du travail\n");
system("pause");
return 0;
}

A3
// Exercice A3
// Affichage du minimum de la suite terminée par 999

OFPPT/DRIF 29
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

#include<stdio.h>
#include<stdlib.h>
int main()
{
int min,elem;
printf("Donner les valeurs de la suite 999 pour finir : ");
scanf("%d",&elem);
if (elem==999) printf("Liste vide\n");
else
{ min=elem;
while (elem!=999)
{ if (elem < min) min=elem ;
scanf("%d",&elem);
}
printf("Le minimum de la suite est : %d\n",min);
}
printf("Fin du travail\n");
system("pause");
return 0;
}

A4
// Exercice A4
// Affichage de la somme des valeurs strictement positifs de la suite terminée par 999
#include<stdio.h>
#include<stdlib.h>
int main()
{
int somme=0,elem ;
printf("Donner les valeurs de la suite 999 pour finir : ");
scanf("%d",&elem);
if (elem==999) printf("Liste vide\n");
else
while (elem != 999)
{ if (elem > 0) somme=somme+elem;
scanf("%d",&elem);
}
printf("La somme des elets > 0 de la suite est : %d\n",somme);
printf("Fin du travail\n");
system("pause");
return 0;
}

A5
// Exercice A5
// Affichage du minimum des valeurs > 0 de la suite terminée par 999
#include<stdio.h>
#include<stdlib.h>
int main()
{

OFPPT/DRIF 30
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

int min,elem;
printf("Donner les valeurs de la suite 999 pour finir : ");
scanf("%d",&elem);
if (elem==999) printf("Liste vide\n");
else while (elem < 0) scanf("%d",&elem);
if (elem == 999) printf("Le minimum n'existe pas!\n");
else {
min=elem;
do { if ((elem > 0) && (min > elem)) min=elem ;
scanf("%d",&elem);
} while (elem != 999);
printf("Le minimum des valeurs > 0 de la suite est : %d\n",min);
}
printf("Fin du travail\n");
system("pause");
return 0;
}

Exercice 7
B1
// Exercice B1
// Affichage de la somme des valeurs lues
#include<stdio.h>
#include<stdlib.h>
int main()
{
int N,elem,somme=0,i=0;
printf("Donner le nbre d'elets de la suite ainsi que les elets : ");
scanf("%d",&N);
if (N==0) printf("Liste vide\n");
else
{ while (i < N) { scanf("%d",&elem);
somme+=elem;
i++;
}
printf("La somme des valeurs lues : %d\n",somme);
}
printf("Fin du travail\n");
system("pause");

OFPPT/DRIF 31
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

return 0;
}

B2
// Exercice B2
// Affichage du minimum
#include<stdio.h>
#include<stdlib.h>
int main()
{
int N,elem,min,i=1;
printf("Donner le nbre d'elets de la suite ainsi que les elets : ");
scanf("%d",&N);
if (N==0) printf("Liste vide\n");
else
{ scanf("%d",&elem);
min=elem;
while (i < N) { scanf("%d",&elem);
if (min > elem) min=elem;
i++;
}
printf("Le minimum de la suite est : %d\n",min);
}
printf("Fin du travail\n");
system("pause");
return 0;
}

B3
// Exercice B3
// Somme des valeurs > 0
#include<stdio.h>
#include<stdlib.h>
int main()
{
int N,elem,somme=0,i=0;
printf("Donner le nbre d'elets de la suite ainsi que les elets : ");
scanf("%d",&N);
if (N==0) printf("Liste vide\n");
else
{
while (i < N) { scanf("%d",&elem);
if (elem > 0) somme+=elem;
i++;
}
printf("La somme des valeurs > 0 est : %d\n",somme);
}
printf("Fin du travail\n");
system("pause");
return 0;

OFPPT/DRIF 32
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

B4
// Exercice B4
// Moyenne des valeurs > 0
#include<stdio.h>
#include<stdlib.h>
int main()
{
int N,elem,somme=0,i=0,occ=0;
float moy;
printf("Donner le nbre d'elets de la suite ainsi que les elets : ");
scanf("%d",&N);
if (N==0) printf("Liste vide\n");
else
{
while (i < N) { scanf("%d",&elem);
if (elem > 0)
{ somme+=elem;
occ++;
}
i++;
}
moy=(float)somme/occ;
printf("La moyenne des valeurs > 0 est : %.2f\n",moy);
}
printf("Fin du travail\n");
system("pause");
return 0;
}

Exercice 8

// Exercice 7
#include <stdio.h>
#include <stdlib.h>
int main () {
for (int i=1;i<=10;i++)
{ for (int j=1;j<=10;j++)
printf("%d\t",i*j);//\t pour tabulation lors de l'affichage
printf("\n");//retour à la ligne après l'affichage de chaque ligne
}
system("pause");
return 0;
}

OFPPT/DRIF 33
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 9
// Exercice 8
#include<stdio.h>
#include<stdlib.h>
int main()
{
for(int i=1;i<=10;i++)
{
for(int j=10-i+1;j>=1;j--)// ou j=j-1
{
printf("* ");
}
printf("\n");
}
system("pause");
return 0;
}

Exercice 10
// Exercice 10
#include<stdio.h>
#include<stdlib.h>
int main()
{
int n,U1=1,U2=1,Un;
printf("Entrez le rang n de Un a calculer : ");
scanf("%d",&n);
for (int i=3;i<=n;i++)
{
Un=U1+U2;

OFPPT/DRIF 34
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

U1=U2;
U2=Un;
}
printf("le terme Un est : %d\n",Un);
system("pause");
return 0;
}

6) Structures de données avancées

1- Tableaux et matrices
a- Tableaux ou vecteurs :
Déclaration : type nom [nombre_d'éléments];
Exemple : int tab[10];
Ceci réserve en mémoire un espace pouvant contenir 10 entiers. Le premier est tab[0],
jusqu'à tab[9] !!! (Source d’erreurs non signalée par le compilateur !).
On peut aussi déclarer un tableau par typedef :
typedef float vecteur[3] ;
vecteur x,y,z ;
On peut aussi initialiser un tableau lors de sa déclaration :
int T[4] = {10,20,30,40} ;
Comme on peut ne pas spécifier la dimension du tableau :
int Y[ ] = {3,5,7} ;
Exemple :
Dans cet exemple, on va sommer 2 vecteurs et afficher le vecteur résultat :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i;
int U[4]={1,2,3,4},V[4]={1,2,3,4},W[4];
for(i=0;i<=3;i++)
{
W[i]=U[i]+V[i];
printf("%d ",W[i]);
}
printf("\nFin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 35
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

On peut aussi déclarer un tableau par typedef :

#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i;
typedef int vecteur[4];
vecteur U={1,2,3,4},V={1,2,3,4},W;
for(i=0;i<=3;i++)
{
W[i]=U[i]+V[i];
printf("%d ",W[i]);
}
printf("\nFin du travail\n");
system("pause");
return 0;
}

b- Matrices :
Déclaration : type nom [nombre_lignes] [nombre_colonnes];
Exemple : float M[3][4] ;
Exemple :
Dans cet exemple, on va sommer 2 matrices et afficher le résultat :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i,j;
typedef int matrice[2][2];//2 lignes 2 colonnes
matrice A={1,2,3,4},B={5,6,7,8},C;//1,2 1ère ligne, 3,4 2ème ligne
for(i=0;i<=1;i++)
{
for(j=0;j<=1;j++)
{
C[i][j]=A[i][j]+B[i][j];
printf("%5d",C[i][j]);//de l'espace pour afficher
}
printf("\n"); printf("\n");
}
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 36
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercices
Exercice 11

Ecrire un programme qui permet de lire un tableau de N valeurs réelles (on suppose N < 20), et
qui permet de :
1. Chercher et afficher le maximum des valeurs du tableau.
2. Compter et afficher le nombre de valeurs négatives du tableau.
3. Rechercher si une valeur se trouve dans le tableau et afficher « trouvé » ou « non trouvé » selon
les cas. (Utilisez la boucle while ou do…while).
4. Calculer et afficher la somme et la moyenne des valeurs strictement positives du tableau.
5. Multiplier toutes les valeurs du tableau par 5 et d’afficher le résultat obtenu.

Exercice 12

Ecrire un programme en C qui calcule et affiche le produit scalaire des 2 vecteurs U =

(1,2,3,4) et V = (5,6,7,8). Ce produit vaut : P = 1x5 + 2x6 + 3x7 + 4x8 = 70.

Exercice 13

Ecrire un programme en C qui permet de saisir, de compter et d’afficher le nombre de

zéros (0) d’une matrice (3 lignes, 3 colonnes).
Exemple :
Soit la matrice :
1 0 2
0 1 0
2 3 0

Le résultat pour cette matrice est : 4 (il y a effectivement 4 zéros dans cette matrice).

Exercice 14
Ecrire un programme en C qui permet de saisir une matrice A (3 lignes, 3 colonnes),
de calculer et d’afficher la matrice transposée de A, c'est-à-dire sa symétrique par
rapport à la diagonale. Pour obtenir cette matrice, il faut échanger les lignes et les
colonnes.
Exemple :
Si A est :
1 2 3
4 5 6
7 8 9

Alors sa transposée est la matrice symétrique par rapport à la diagonale :

1 4 7
2 5 8
3 6 9

OFPPT/DRIF 37
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 15
Ecrire un programme en C qui permet de saisir 2 matrices A et B (3 lignes, 3
colonnes), de calculer et d’afficher la matrice produit C = A x B.

Exercice 16

Les exercices de cette série doivent être résolus 2 fois : une première fois, en supposant que les
données sont en nombre inconnu se terminant par 999 ; et une deuxième fois en supposant que les
données sont en nombre connu en mettant le nombre de valeurs de la suite au début.
Dans les 2 cas, on supposera qu’il n’y a pas plus 20 valeurs dans la suite donnée.
Les résultats indiqués seront valables pour la suite : 12 -4 6 4 6
C1. Ecrire les valeurs dans l’ordre inverse de leur lecture.
Résultat : 6 4 6 -4 12
Suggestion : ranger les valeurs dans un tableau intermédiaire
C2. Comme dans C1, mais on doit ignorer les valeurs négatives.
Résultat : 6 4 6 12
C3. Lire les données et faire afficher le nombre d’apparition de chacun des entiers 1, 2,…,10.
(Les données peuvent ici contenir plus de 20 valeurs).
Résultat :
Nombre de 4 : 1
Nombre de 6 : 2
Suggestion : un tableau de compteurs sera très commode.

Exercice 17

On travaille ici avec 2 vecteurs (d’au plus 20 valeurs), que nous appellerons A et B.
E1. Phase d’initialisation des 2 vecteurs : lire N, puis lire N valeurs et les mettre dans A[1],…
A[N], puis lire N valeurs et les mettre dans B[1],… B[N].
Les exercices suivants supposent que cette phase d’initialisation vient d’être faite.
E2. Calculer (et afficher) la valeur V = A[1]*B[1] +… A[N]*B[N].
E3. Faire écrire OUI ou NON selon que la valeur A[1] se trouve ou non dans B.
E4. Faire écrire OUI ou NON selon que l’une (au moins) des valeurs de A se trouve (ou non) dans
B.
E5. Faire écrire OUI ou NON selon que toutes les valeurs de A se trouvent (ou non) dans B.
Attention : l’ordre des valeurs peut être différent dans A et dans B.

Exercice 18

F1. Lire une matrice de N lignes et M colonnes ligne par ligne. Les données sont dans l’ordre :
N M
A[1,1] … A[1,M]
…
A[N,1] … A[N,M]
Ecrire ensuite cette matrice ligne par ligne.
Les exercices suivants supposent que cette phase d’initialisation vient d’être faite.
F2. Compter (et afficher) le nombre de zéros de chaque colonne.
F3. Compter (et afficher) le nombre de colonnes contenant au moins un zéro.
F4. Afficher le minimum de chaque colonne.
F5. Afficher le numéro de la colonne contenant le minimum de la matrice. (A égalité, donner le
plus petit numéro de colonne).

OFPPT/DRIF 38
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 19

G1. Tabulation d’un polynôme.

Données : le degré N du polynôme ; les coefficients commençant par celui du terme de degré N ;
puis une série de valeurs de la variable X (toutes différentes de 999), série terminée par 999.
Résultats à produire : pour chaque valeur lue de la variable X, une ligne contenant X et la valeur
correspondante du polynôme P(X). (Coefficients et valeurs de X sont des entiers).
G2. Faire le produit d’une matrice A (de dimension NxM) et d’une matrice B (de dimension MxP)
pour obtenir une matrice C (de dimension NxP).
Lire N, M et P correspondant aux dimensions des matrices A et B.
Lire ensuite (ligne par ligne) les éléments de A, puis ceux de B.
Calculer la matrice C comme produit de A et de B.
Ecrire la matrice A, la matrice B et la matrice C.
(On supposera que N, M, P <= 15 et que toutes les valeurs sont entières).

Corrigés
Exercice 11
// Exercice 11
#include <stdio.h>
#include <stdlib.h>
int main (){
int N,compt_neg=0,compt_pos=0,j=0;
float S=0.0,max,V,moy,T[20];//T : tableau de 20 reels
printf("Entrez la dimension du tableau :");
scanf("%d",&N);
//lecture du tableau :
printf("Entrez les N valeurs du tableau :");
for (int i=0;i<N;i++)
scanf("%f",&T[i]);
//1.Chercher et afficher le maximum des valeurs du tableau :
max=T[0];
for (int i=1;i<N;i++)
if (T[i]>max) max=T[i];
printf("Le maximum des valeurs du tableau est : %.2f\n",max);
//2.Compter et afficher le nombre de valeurs négatives du tableau :
for (int i=0;i<N;i++)
if (T[i]<0) compt_neg++;
printf("Le nombre de valeurs negatives du tableau est : %d\n",compt_neg);
//3.Rechercher si une valeur se trouve dans le tableau :
printf("Entrez la valeur recherchee :");
scanf("%f",&V);
while ((T[j]!=V) && (j<=N))
j++;
if (j<N) printf("Valeur trouvee\n");
else printf("Valeur non trouvee\n");
//4.Calculer et afficher la somme et la moyenne des valeurs strictement positives du tableau :
for (int i=0;i<N;i++)
if (T[i]>0) {
S=S+T[i];
compt_pos++;
}
moy=S/compt_pos;

OFPPT/DRIF 39
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

printf("La somme des valeurs strictement positives du tableau est : %.2f\n",S);

printf("La moyenne des valeurs strictement positives du tableau est : %.2f\n",moy);
//5.Multiplier toutes les valeurs du tableau par 5 et d'afficher le résultat obtenu :
printf("Affichage des valeurs du tableau * 5 :\n");
for (int i=0;i<N;i++)
printf("%10.2f",5*T[i]);
printf("\n");
system("pause");
return 0;
}

Exercice 12
// Exercice 12
#include <stdio.h>
#include <stdlib.h>
int main ()
{
typedef int vecteur[4];
vecteur U={1,2,3,4},V={5,6,7,8};
int PS=0;
for(int i=0;i<=3;i++)
PS=PS + (U[i]*V[i]);//fin boucle for
printf("Le produit scalaire des 2 vecteurs U et V est : %d\n",PS);
system("pause");
return 0;
}

Exercice 13
// Exercice 13
#include <stdio.h>
#include <stdlib.h>
int main ()
{
typedef int mat[3][3];//3 lignes 3 colonnes
mat A;
int compt=0;
printf("Entrez les 9 valeurs de la matrice A:");
//lecture de A et comptage de 0:
for(int i=0;i<=2;i++)
for(int j=0;j<=2;j++)
{
scanf("%d",&A[i][j]);
if (A[i][j]==0) //le symbole d'égalité == à ne pas confondre avec l'affectation =
compt++;

OFPPT/DRIF 40
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

}//fin de boucle
printf("Le nombre de 0 de la matrice A est : %d\n",compt);
system("pause");
return 0;
}

Exercice 14
// Exercice 14
#include <stdio.h>
#include <stdlib.h>
int main ()
{
const int TMAX=3;

typedef int matrice[TMAX][TMAX];

matrice A;
int aux;//variable auxiliaire permettant d'échanger 2 valeurs
//Lecture de A :
printf("Entrez les 9 valeurs de la matrice A : ");
for(int i=0;i<TMAX;i++)//on commence par l'indice 0!
for(int j=0;j<TMAX;j++)
scanf("%d",&A[i][j]);
//Calcul de la transposée
for(int i=0;i<TMAX;i++)//on commence par l'indice 0!
for(int j=0;j<i;j++)
{ //échange de A[i][j] et A[j][i]
aux=A[i][j];
A[i][j]=A[j][i];
A[j][i]=aux;
}
//Affichage de la transposée
printf("Voici la matrice transposee de A :\n");
for(int i=0;i<TMAX;i++)
{ for(int j=0;j<TMAX;j++)
printf("%5d",A[i][j]);
printf("\n");
}
system("pause");
return 0;
}

OFPPT/DRIF 41
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 15
// Exercice 15
#include <stdio.h>
#include <stdlib.h>
int main ()
{
const int TMAX=3;
typedef int matrice[TMAX][TMAX];
matrice A,B,C;
//Lecture de A :
printf("Entrez les 9 valeurs de la matrice A : ");
for(int i=0;i<TMAX;i++)
for(int j=0;j<TMAX;j++)
scanf("%d",&A[i][j]);
//Lecture de B :
printf("Entrez les 9 valeurs de la matrice B : ");
for(int i=0;i<TMAX;i++)
for(int j=0;j<TMAX;j++)
scanf("%d",&B[i][j]);
//Calcul de la matrice produit C :
printf("Voici la matrice transposee de A :\n");
for(int i=0;i<TMAX;i++)
{
for(int j=0;j<TMAX;j++)
{
C[i][j]=0;
for(int k=0;k<TMAX;k++)
C[i][j]=C[i][j]+(A[i][k]*B[k][j]);
printf("%10d",C[i][j]);
}
printf("\n");
}
system("pause");
return 0;
}

OFPPT/DRIF 42
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

6-bis) Structures de données avancées « suite »

2- Pointeurs
Les pointeurs sont des variables contenant des adresses.
Exemple1 commenté :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int i=17,j;
int *p; //déclaration du pointeur
p=&i; //p pointe sur l'adresse de i
j=*p; //c'est la même chose que j = i;
printf("j = %d\n",j);
printf("p = %d\n",*p);
*p=22;
printf("p = %d\n",*p);
printf("i = %d\n",i);
printf("Fin du travail\n");
system("pause");
return 0;
}

Exemple2 commenté :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
double A = 1, B = 2;
double *P1;
P1=&A;
printf("adresse de A: %d\n",P1);
printf("valeur de A: %f\n",A);
printf("Valeur contenue dans l'adresse de A: %f\n",*P1);
*P1=3;
printf("Valeur de A: %f\n",A);
P1=&B;
printf("Adresse de B: %d\n",P1);
printf("Valeur contenue dans l'adresse de B: %f\n",*P1);
P1++;
printf("Adresse contenue dans P1 après incrémentation: %d\n",P1);//il rajoute 8 octets comme c’est un
double
printf("Valeur contenue dans *P1: %f\n",*P1);
(*P1)++;
printf("Adresse contenue dans P1 après incrémentation: %d\n",P1);
printf("Valeur de *P1: %f\n",*P1);
printf("Valeur de B: %f\n",B);
system("pause");
return 0;

OFPPT/DRIF 43
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Allocation dynamique d’une variable et libération de la mémoire

Quand une variable est déclarée dans un programme, Le système d’exploitation se
charge d’allouer (ou réserver) automatiquement de l’espace mémoire suffisant pour
cette variable. En revanche, On peut demander manuellement de l’espace mémoire au
S.E., c’est ce qu'on appelle de l'allocation dynamique de mémoire.
Taille des variables
On a déjà vu que selon le type de variable (char, int, double, float...), on a besoin de
plus ou moins de mémoire. Exemple, un « char » tient sur 1 octet, un « int » sur 4
octets…
Pour vérifier cela, on dispose d’une fonction en C : sizeof(type de données).
Exemple :
#include<stdio.h>
#include<stdlib.h>
int main()
{
printf("char : %d octets\n", sizeof(char));
printf("int : %d octets\n", sizeof(int));
printf("long : %d octets\n", sizeof(long));
printf("float : %d octets\n", sizeof(float));
printf("double : %d octets\n", sizeof(double));
system("pause");
return 0;
}

Peut-on afficher la taille d'un type personnalisé qu'on a créé, un tableau par exemple ?
Cela est possible grâce toujours à sizeof(tableau) :
Exemple :

OFPPT/DRIF 44
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

#include<stdio.h>
#include<stdlib.h>
int main()
{
int T[3];// 3 x taille de int = 12 octets
printf("Le tableau T de 3 int : %d octets\n", sizeof(T));
system("pause");
return 0;
}

Donc, en suivant ce même principe, la déclaration suivante :

int tableau[100]; fait occuper 4 x 100 = 400 octets en mémoire, même si le tableau est
vide !
Allocation dynamique de la mémoire
Pour pouvoir allouer de façon dynamique la mémoire, on a besoin d’inclure la
bibliothèque <stdlib.h> qui contient 2 fonctions :
 malloc ("Memory ALLOCation", c'est-à-dire "Allocation de mémoire") :
demande au système d'exploitation la permission d'utiliser de la mémoire.
 free ("Libérer") : permet d'indiquer au S.E. que l'on n'a plus besoin de la
mémoire qu'on avait demandée. La place en mémoire est libérée, un autre
programme peut maintenant s'en servir au besoin.
Exemple :
On va écrire un programme en C qui demande l'âge à l'utilisateur et qui va le lui
afficher.
La variable utilisée va être allouée manuellement (ou dynamiquement) au lieu
d'automatiquement par le S.E.
#include<stdio.h>
#include<stdlib.h>// nécessaire pour utiliser malloc et free
int main()
{
int *memoireAllouee = NULL;// On crée un pointeur sur int car malloc renvoie void* (un pointeur)
memoireAllouee = (int*) malloc(sizeof(int)); // Allocation de la mémoire
//test du pointeur : si l'allocation a marché, le pointeur contient une adresse, sinon il contient l’adresse NULL
if (memoireAllouee == NULL)// Si l'allocation a échoué
{
exit(0);// On arrête immédiatement le programme
}
// Utilisation de la mémoire
printf("Quel age avez-vous ? ");
scanf("%d",memoireAllouee);

OFPPT/DRIF 45
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

printf("Vous avez %d ans\n",*memoireAllouee);

free(memoireAllouee); // Libération de mémoire
system("pause");
return 0;
}

Si on opte pour l’allocation automatique de la mémoire (# à dynamique), le

programme précédent est équivalent à :
#include<stdio.h>
#include<stdlib.h>// Facultatif
int main()
{
int age = 0; // Allocation de la mémoire (automatique) par le S.E
// Utilisation de la mémoire
printf("Quel age avez-vous ? ");
scanf("%d",&age);
printf("Vous avez %d ans\n",age);
system("pause");
return 0;
}// Libération de la mémoire (automatique à la fin de la fonction) par le S.E

Allocation dynamique d’un tableau

La vraie utilité de l’allocation dynamique est pour créer un tableau dont on ne connaît
pas la taille avant l’exécution du programme.
Exemple 1 :
On veut écrire un programme qui stocke l'âge de tous les amis de l'utilisateur dans un
tableau, on peut utiliser : int ageAmis[15]; le problème est que l’on ne sait pas à
l’avance le nombre d’amis de l’utilisateur, on ne le saura qu’à l’exécution du
programme.
Voici une solution :
#include<stdio.h>
#include<stdlib.h>
int main()
{
int nombreDAmis = 0, i = 0;
int* ageAmis = NULL; // Ce pointeur va servir de tableau après l'appel du malloc
// On demande le nombre d'amis à l'utilisateur
printf("Combien d'amis avez-vous ? ");
scanf("%d", &nombreDAmis);
if (nombreDAmis > 0) // Il faut qu'il ait au moins un ami
{

OFPPT/DRIF 46
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

ageAmis = (int*) malloc(nombreDAmis * sizeof(int)); // On alloue de la mémoire pour le tableau

if (ageAmis == NULL) // On vérifie si l'allocation a marché ou pas
{
exit(0); // On arrête tout
}
// On demande l'âge des amis un à un
for (i = 0 ; i < nombreDAmis ; i++)
{
printf("Quel age a l'ami numero %d ? ", i + 1);
scanf("%d", &ageAmis[i]);
}
// On affiche les âges stockés un à un
printf("\n\nVos amis ont les ages suivants :\n");
for (i = 0 ; i < nombreDAmis ; i++)
{
printf("%d ans\n", ageAmis[i]);
}
// On libère la mémoire allouée avec malloc, on n'en a plus besoin
free(ageAmis);
}
system("pause");
return 0;
}

Exemple 2 :
Cas d’un tableau à deux dimensions :
#include<stdio.h>
#include<stdlib.h>
int main()
{
int n ;
int k ;
int ** tab;
int i;
int j;

printf("Entrez le nombre de lignes : ");

scanf("%d",&k);
printf("Entrez le nombre de colonnes : ");
scanf("%d",&n);

tab = (int ** ) malloc (k * n * sizeof (int));

if (tab == NULL) // On vérifie si l'allocation a marché ou pas
{
exit(0); // On arrête tout
}
for (i = 0; i < k; i = i + 1)
{

OFPPT/DRIF 47
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

for (j = 0; j < n; j = j + 1)
{
tab[i][j] = i + j;
}
}
for (i = 0; i < k; i = i + 1)
{
for (j = 0; j < n; j = j + 1)
{
printf("Element de la ligne %d et de colonne %d : %d \n",i,j,tab[i][j]);
}
}
free (tab);
system("pause");
return 0;
}

3- Structures
Jusque là, nous avons toujours utilisés des variables contenants les mêmes types de
données (tableaux ou matrices d’entiers ou réels…), les structures sont des variables
composées de plusieurs variables (ou CHAMPS) de types différents :

Exemple :
#include <stdio.h>
#include <stdlib.h>
int main ()
{
struct point
{ int x;
int y; //x et y sont les champs de la struct point
};
struct point a,b;//déclaration de variables de type point
a.x=1;
a.y=2;
b.x=3;
b.y=4;
printf("la valeur de l'abscisse de a est : %d\n",a.x);
printf("la valeur de l'ordonnee de b est : %d\n",b.y);
printf("Fin du travail\n");
system("pause");
return 0;
}

Exercice 20

Ecrire un programme en C qui permet de déclarer une structure nommée « ensemble »

comportant un entier, un réel et un tableau de caractères, ce programme doit permettre
de saisir les composantes de cette structure et de les afficher.

OFPPT/DRIF 48
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Corrigé
#include <stdio.h>
#include <stdlib.h>
int main ()
{
struct ensemble
{ int n;
float x;
char texte[50];
};
struct ensemble E;
int i=0;
char c;
//saisi des composantes de la structure :
printf("Entrez un entier : ");
scanf("%d",&E.n);
printf("Entrez un reel : ");
scanf("%f",&E.x);
printf("Entrez un texte, tapez . pour terminer : ");
c=getchar();
gets(E.texte);

//affichage des composantes de la structure :

printf("\nAffichage des composantes de la structure E :\n");
printf("L'entier E.n = %d\n",E.n);
printf("Le reel E.x = %.2f\n",E.x);
printf("Le texte E.texte = ");
puts(E.texte);
printf("\n");
system("pause");
return 0;
}

OFPPT/DRIF 49
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

7) Fonctions
Une fonction est définie par son entête, suivie d'un bloc d'instructions
Déclaration : type_retourné nom_fonction(liste_arguments ou paramètres).
Exemple : int carre (int x) { … } : carre est une fonction qui retourne un entier et qui a
comme paramètre un entier.
Si la fonction ne retourne rien on indique : void. (c’est l’équivalent des procédures en
PASCAL).
Exemples : - float nom_fonction(int a, float b) {bloc d’instructions}
- void nom_fonction() {bloc d’instructions} : fonction sans paramètre et ne
retournant rien (void).
Exemple1 :
#include <stdio.h>
#include <stdlib.h>

void debut() // debut retourne rien

{
printf("Programme de calcul de la somme des carrés des nombres de 1 à 2 \n");

void fin(int a) // a paramètre formel

{ printf("valeur finale = %d\n",a);
}

int carre(int x)
{ int v;
v=x*x;
return v; // carre retourne un entier
}

int main ()
{
int i,total;
debut();
total=0;

for(i=1;i<=2;i++)
total=total+carre(i);

fin(total);
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 50
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Passage des paramètres d’une fonction

1- Par référence : L’argument ou (paramètre effectif) remplace le paramètre formel et
toute modification de la valeur du paramètre (à l’intérieur de la fonction) modifie la
valeur de l’argument. Il suffit de mettre & devant le nom du paramètre pour que le
passage soit par référence. Si le paramètre formel est un tableau le passage se fait
toujours par référence.
2- Par valeur : l’argument est recopié dans une variable locale et le paramètre désigne
cette variable. Toute modification de la valeur du paramètre modifie la variable locale.
L’argument n’est pas modifié.
Exemple2 :
#include <stdio.h>
#include <stdlib.h>

void compte1(int i)//passage par valeur

{
i++;
printf("\nLa valeur du parametre de compte1 : %d\n",i);
}
void compte2(int &j)//passage par référence
{
j++;
printf("\nLa valeur du parametre de compte2 : %d\n",j);
}
void compte3(int t[3]) //tableau donc par référence
{
t[1]++;
printf("\nLa valeur du parametre de compte3 : %d\n",t[1]);
}
int main ()
{
int a,b,r[3];
a=b=r[1]=1;//initialisations multiples
compte1(a);
printf("La valeur de l'argument de compte1 : %d\n",a);

compte2(b);
printf("La valeur de l'argument de compte2 : %d\n",b);

compte3(r);
printf("La valeur de l'argument de compte3 : %d\n",r[1]);
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 51
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 23
Ecrivez un programme qui réalise le produit des 2 matrices :
1 0 1 2 3 4
0 1 0 0 7 0
1 0 1 2 3 4

Utilisez 2 fonctions : prodmat pour calculer le produit et ecritmat pour l’afficher.

Corrigé
#include <stdio.h>
#include <stdlib.h>
const int TMAX=3;
typedef int matrice[TMAX][TMAX];

void prodmat(matrice m1,matrice m2,matrice m3)//matrice passage par référence

{
for(int i=0;i<TMAX;i++)//on commence par l'indice 0!
for(int j=0;j<TMAX;j++)
{ int s=0;
for(int k=0;k<TMAX;k++) s=s+(m1[i][k]*m2[k][j]);//() non nécessaire car priorité
m3[i][j]=s;
}
}
void ecritmat(matrice mat)
{
for(int i=0;i<TMAX;i++)
{ for(int j=0;j<TMAX;j++)
printf("%5d",mat[i][j]);
printf("\n");
}
}
int main ()
{
matrice mat1={{1,0,1},{0,1,0},{1,0,1}};
matrice mat2={{2,3,4},{0,7,0},{2,3,4}};
matrice mat3;
prodmat(mat1,mat2,mat3);
ecritmat(mat3);
printf("Fin du travail\n");
system("pause");
return 0;
}

OFPPT/DRIF 52
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exercice 24
Ecrire un programme en langage C, contenant 4 fonctions réalisant les questions F1,
F2, F3 et F4, qui permet de :
F1. Lire une matrice de N lignes et M colonnes ligne par ligne. Les données sont dans
l’ordre :
N M
A[1,1] … A[1,M]
…
A[N,1] … A[N,M]
F2. Ecrire ensuite cette matrice ligne par ligne.
Les exercices suivants supposent que cette phase d’initialisation vient d’être faite.
F3. Afficher le minimum de chaque colonne.
F4. Afficher le numéro de la colonne contenant le minimum de la matrice. (A égalité,
donner le plus petit numéro de colonne).

Corrigé
#include<stdio.h>
#include<stdlib.h>
typedef int matrice[10][10];
typedef int tableau[10];
int N,M,numero;//N:nbre de lignes, M:colonnes
//*******************************************
void lecture (matrice T)
{ for (int i=1;i<=N;i++)
for (int j=1;j<=M;j++)
scanf("%d",&T[i][j]);
}
//*******************************************
void mini_col (matrice T, tableau tabmin)
{ int min;
for (int j=1;j<=M;j++)
{
min=T[1][j];
for (int i=2;i<=N;i++)
if (min>=T[i][j]) min=T[i][j];
tabmin[j]=min;
}
}
//*******************************************
int mini_mat (tableau vect)
{ int minimum=vect[1];
for (int i=2;i<=M;i++)
if (minimum>vect[i])
{ minimum=vect[i];
numero=i;//repérer la colonne contenant le minimum
}
return numero;
}
//*******************************************
void ecriture (matrice T)
{ for (int i=1;i<=N;i++)
{
for (int j=1;j<=M;j++)

OFPPT/DRIF 53
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

printf("%5d",T[i][j]);
printf("\n");
}
}
//*******************************************
int main()
{
matrice A;
tableau V;
printf("donner le nombre de lignes et de colonnes : ");
scanf("%d %d",&N,&M);
printf("rentrer la matrice ligne par ligne : \n");
lecture(A);
mini_col(A,V);
mini_mat(V);
printf("le numero de la colonne contenant le minimum de la matrice est : %2d\n",mini_mat(V));
ecriture(A);
system("pause");
return 0;
}

Exercice 25
Dans cet exercice, on va passer en revue certains algorithmes de tri bien connus des
tableaux. On va se proposer de les rassembler dans un même programme, et on
affectera à chaque méthode de tri une fonction correspondante de manière à ce qu’on
puisse comparer ces différentes méthodes.

Rappels :
Un tableau T est dit « trié en ordre croissant » si tous les éléments consécutifs du
tableau vérifient : T[i-1]  T[i]
Exemple de tableau trié : -6 0 12 25 100

Tri par sélection :

Le principe du tri par sélection d'un tableau est d'aller chercher le plus petit élément du
tableau pour le mettre en premier, puis de repartir du deuxième, d'aller chercher le plus
petit élément pour le mettre en 2ème position et ainsi de suite...
Au ième passage, on sélectionne l’élément ayant la plus petite valeur parmi les
positions i..n et on l'échange avec T[i].
Voici l’algorithme correspondant :

OFPPT/DRIF 54
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Entier i,j
Début
pour i 1 à n-1 faire
pour j i+1 à n faire
si T[i] > T[j] alors
échange(T,i,j)
fsi
fpour
fpour
Fin

Exemple :

4 5 0 2 3 Tableau de départ
0 5 4 2 3 Le plus petit élément est à sa place
0 2 4 5 3 Les 2 plus petits éléments sont à leur place
0 2 3 5 4 Les 3 plus petits éléments sont à leur place
0 2 3 4 5 Les 4 plus petits éléments sont à leur place

Tri à bulles :
Le principe du tri à bulles (bubble sort) est de comparer deux à deux les éléments e1 et
e2 consécutifs d'un tableau et d'effecteur une permutation si e1 > e2.
On continue de trier jusqu'à ce qu'il n'y ait plus de permutation.
Voici l’algorithme correspondant :
Entier i,j
Début
pour i 1 à n-1 faire
pour j n à i+1 faire {décroissant}

si T[j-1] > T[j] alors

échange(T,j-1,j)
fsi
fpour
fpour
Fin
Exemple :
4 2 0 3 5 Tableau de départ
0 4 2 3 5 Fin du 1er passage
0 2 4 3 5 Fin du 2ème passage
0 2 3 4 5 Fin du 3ème passage
Enoncé de l’exercice 25
Ecrire un programme utilisant 4 fonctions :
 Une fonction de lecture d’un tableau,

OFPPT/DRIF 55
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

 Une fonction de tri par sélection de ce tableau,

 Une fonction de tri par bulles de ce tableau,
 Une fonction d’affichage du tableau trié.
Corrigé
#include<stdio.h>
#include<stdlib.h>
typedef int tableau[15];
int N;
// *************************************************
// Lecture du tableau
void lecture(tableau T)
{
for (int i=0;i<N;i++)
scanf("%d",&T[i]);
}
// *************************************************
// Tri par sélection
void tri_selection(tableau T)
{
int aux;
for (int i=0;i<N-1;i++)
for (int j=i+1;j<N;j++)
if (T[i]>T[j])
{ aux=T[i];
T[i]=T[j];
T[j]=aux;
}
}
// *************************************************
// Tri par bulles
void tri_bulles(tableau T)
{
int aux;
for (int i=0;i<N-1;i++)
for (int j=N-1;j>=i+1;j--)
if (T[j-1]>T[j])
{ aux=T[j-1];
T[j-1]=T[j];
T[j]=aux;
}
}
// *************************************************
// Affichage du tableau
void affichage(tableau T)
{
for (int i=0;i<N;i++)
printf("%5d",T[i]);
printf("\n");
}
// *************************************************
int main()
{
tableau V;
printf("Entrer la dimension du tableau : ");
scanf("%d",&N);
printf("Entrer les N valeurs du tableau : ");
lecture(V);
tri_selection(V);

OFPPT/DRIF 56
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

printf("Voici le tableau trie par selection :\n");

affichage(V);
printf("Entrer de nouveau N autres valeurs du tableau : ");
lecture(V);
tri_bulles(V);
printf("Voici le tableau trie par bulles :\n");
affichage(V);
system("pause");
return 0;
}

8) Fichiers de données :
Notion de fichier
Un fichier (file en anglais) est un ensemble structuré de données stocké en général sur
un support externe (clé USB, disque dur, disque optique, bande magnétique, ...).
Fichier séquentiel.
Dans des fichiers séquentiels, les enregistrements sont mémorisés consécutivement
dans l'ordre de leur entrée et peuvent seulement être lus dans cet ordre. Si on a besoin
d'un enregistrement précis dans un fichier séquentiel, il faut lire tous les
enregistrements qui le précèdent, en commençant par le premier.
Exemple :

Il existe 2 fichiers spéciaux qui sont définis par défaut pour tous les programmes :
- stdin le fichier d'entrée standard (clavier)
- stdout le fichier de sortie standard (l’écran).
Cela signifie que les programmes lisent leurs données au clavier et écrivent les
résultats sur l'écran.

OFPPT/DRIF 57
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

La mémoire tampon (buffer)

Pour des raisons d'efficacité, les accès à un fichier se font par l'intermédiaire d'une
mémoire tampon (buffer en anglais). La mémoire tampon est une zone de la mémoire
centrale de l’ordinateur réservée à un ou plusieurs enregistrements du fichier.
L'utilisation de la mémoire tampon a l'effet de réduire le nombre d'accès à un
périphérique de stockage d'une part et le nombre des mouvements de la tête de
lecture/écriture d'autre part :

Ouverture et fermeture de fichiers

L'ouverture et la fermeture de fichiers se font à l'aide des fonctions fopen et fclose
définies dans la bibliothèque standard <stdio>.
La commande fopen permet d’ouvrir des fichiers en écriture, en lecture, en ajout …etc:
fopen ( <Nom> , "w" ) : écriture, fopen ( <Nom> , "r" ) : lecture,
fopen ( <Nom> , "a" ) : ajout.
La commande fopen accepte les paramètres suivants :
r Ouvre le fichier en lecture. Le pointeur de flux est placé au début du fichier.
r+ Ouvre le fichier en lecture et écriture. Le pointeur de flux est placé au début
du fichier.
w Tronque le fichier à son début ou ouvre le fichier en écriture. Le pointeur de
flux est placé au début du fichier.
w+ Ouvre le fichier en lecture et écriture. Le fichier est créé s'il n'existait pas. S'il
existait déjà, sa longueur est ramenée à 0. Le pointeur de flux est placé au
début du fichier.
a Ouvre le fichier en ajout (écriture à la fin du fichier). Le fichier est créé s'il
n'existait pas. Le pointeur de flux est placé à la fin du fichier.
a+ Ouvre le fichier en lecture et ajout (écriture en fin de fichier). Le fichier est
créé s'il n'existait pas. La tête de lecture initiale du fichier est placée au début
du fichier mais la sortie est toujours ajoutée à la fin du fichier.

Ouverture en écriture :
- Dans le cas de la création d'un nouveau fichier, le nom du fichier est ajouté au
répertoire de stockage.
- Si un fichier existant est ouvert en écriture, alors son contenu est perdu.

OFPPT/DRIF 58
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

- Si un fichier non existant est ouvert en écriture, alors il est créé automatiquement. Si
la création du fichier est impossible alors fopen indique une erreur en retournant la
valeur zéro.
Exemples :
Exemple1 :
L’exemple suivant permet la création du fichier : « fichier1.txt » à la racine du
disque « d : », et insère le texte : « Création d'un nouveau fichier » dans ce fichier :

#include <stdio.h>
#include <stdlib.h>
int main ()
{
FILE *index=NULL;//déclaration de fichiers
index = fopen("d:\\fichier1.txt","w");//ouverture en écriture
if (index == NULL) printf("Probleme d'ouverture\n");
else printf("Pas de probleme d'ouverture\n");
fputs("Creation d'un nouveau fichier", index);
fclose(index);
printf("Fin du travail\n");
system("pause");
return 0;
}

Exemple 2 :
Cet exemple nous montre que l’ouverture en écriture d’un fichier existant a pour effet
de faire perdre son contenu :
Voici le contenu du fichier précédent ouvert en écriture :

#include <stdio.h>
#include <stdlib.h>
int main ()
{
FILE *index;//déclaration de fichiers
index = fopen("d:\\fichier1.txt","w");//ouverture en écriture
if (index == NULL) printf("Probleme d'ouverture\n");
else printf("Pas de probleme d'ouverture\n");
fputs("Ouverture en écriture d'un fichier existant, son contenu est alors perdu!", index);
fclose(index);
printf("Fin du travail\n");
system("pause");
return 0;
}
Exemple 3 :
Le programme suivant contrôle si l’ouverture du fichier a été réalisée avec succès,
d’abord l’ouverture en écriture :

OFPPT/DRIF 59
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

#include <stdio.h>
#include <stdlib.h>
main()
{

FILE *index=NULL; /* pointeur sur FILE */

char nom_fichier[30]; /* nom du fichier */

do
{
printf("Entrez le nom du fichier : ");
scanf("%s", nom_fichier);
index = fopen(nom_fichier, "w");
if (!index)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", nom_fichier);
}
while (!index);
printf("\a ouverture du fichier %s.\n", nom_fichier);
system("pause");
fclose(index);
return 0;
}

Exemple 4 :
Ensuite l’ouverture en lecture :
#include <stdio.h>
#include <stdlib.h>
main()
{
FILE *index; /* pointeur sur FILE */
char nom_fichier[30]; /* nom du fichier */

do
{
printf("Entrez le nom du fichier : ");
scanf("%s", nom_fichier);
index = fopen(nom_fichier, "r");
if (!index)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", nom_fichier);
}while (!index);
fclose(index);
system("pause");
return 0;
}

Lire et écrire dans des fichiers séquentiels

OFPPT/DRIF 60
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Les fichiers que nous manipulons ici sont des fichiers texte, cela signifie que toutes les
informations dans les fichiers sont mémorisées sous forme de chaînes de caractères et
sont organisées en lignes. Même les valeurs numériques (types int, float, double, ...)
sont stockées comme chaînes de caractères.
Pour l'écriture et la lecture des fichiers, nous allons utiliser les fonctions standard
fprintf, fscanf, fputc et fgetc qui correspondent à printf, scanf, putchar et getchar…
Exemple 5 :
Ecrire un programme qui ouvre un fichier en écriture « w » et qui affiche dedans 5
entiers saisis au clavier. On utilisera la fonction : fprintf.
// Programme qui écrit 5 entiers dans un fichier ouvert en écriture
#include <stdio.h>
#include <stdlib.h>
main()
{
FILE *index; /* pointeur sur FILE */
char nom_fichier[30]; /* nom du fichier */
int n;
do
{
printf("Entrez le nom du fichier : ");
scanf("%s", nom_fichier);
index = fopen(nom_fichier, "w");
if (!index)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", nom_fichier);
}while (!index);
printf("Saisir 5 entiers : ");
for (int i=1;i<=5;i++)
{
scanf("%d",&n);
fprintf(index, "%d\n", n);
}
fclose(index);
system("pause");
return 0;
}

OFPPT/DRIF 61
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exemple 6 :
Ecrire un programme qui ouvre, en lecture, le fichier crée par le programme précédent
et qui lit et affiche les 5 entiers insérés dans ce fichier.
// Programme qui ouvre, en lecture, le fichier crée par le programme précédent
//et qui lit et affiche les 5 entiers insérés dans ce fichier
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *index; /* pointeur sur FILE */
char nom_fichier[30]; /* nom du fichier */
int n;
do
{
printf("Entrez le nom du fichier : ");
scanf("%s", nom_fichier);
index = fopen(nom_fichier, "r");
if (!index)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", nom_fichier);
}while (!index);
for (int i=1;i<=5;i++)
{
fscanf(index, "%d",&n);
printf("%d\n",n);
}
fclose(index);
system("pause");
return 0;
}

OFPPT/DRIF 62
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Exemple 7 :
Le programme suivant lit et affiche un fichier de texte en le parcourant caractère par
caractère:
// Programme qui lit un fichier de texte
#include <stdio.h>
#include <stdlib.h>
main()
{
FILE *index; /* pointeur sur FILE */
char nom_fichier[30]; /* nom du fichier */
int n;
do
{
printf("Entrez le nom du fichier : \n");
scanf("%s", nom_fichier);

index = fopen(nom_fichier, "r");

if (!index)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", nom_fichier);
}
while (!index);
printf("\n \n");
while (!feof(index))
putchar(fgetc(index));
printf("\n \n");
fclose(index);
system("pause");
return 0;
}

Dans une chaîne de caractères constante, il faut indiquer le symbole '\' (back-slash) par
'\\', pour qu'il ne soit pas confondu avec le début d'une séquence d'échappement
(p.ex: \n, \t, \a, ...).

Exercice 26 : « récapitulatif »

Créer le fichier INFORMATION.TXT dont les informations (informations générales
sur des personnes : clients…) sont structurées de la manière suivante :
- Numéro de matricule (entier)
- Nom (chaîne de caractères)
- Prénom (chaîne de caractères)
- Le nombre d'enregistrements à créer est à entrer au clavier par l'utilisateur.

OFPPT/DRIF 63
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

Corrigé
#include <stdio.h>
#include <stdlib.h>
int main()
{
// Déclarations
// Nom du fichier et pointeur de référence
char NOM_FICH[50];
FILE *FICHIER;
// Autres variables :
char NOM[30], PRENOM[30];
int MATRICULE;
int N_ENR;
do
{
printf("Entrez le nom du fichier : ");
scanf("%s", NOM_FICH);
// Ouverture du nouveau fichier en écriture
FICHIER = fopen(NOM_FICH, "w");

if (!FICHIER)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", NOM_FICH);
}
while (!FICHIER);

// Saisie des données et création du fichier

printf("*** Creation du fichier %s ***\n", NOM_FICH);
printf("Nombre d'enregistrements a creer : ");
scanf("%d",&N_ENR);
for (int i=1;i<=N_ENR;i++)
{
printf("Enregistrement No: %d \n", i);
printf("Numero de matricule : ");
scanf("%d",&MATRICULE);
printf("Nom : ");
scanf("%s",NOM);
printf("Prénom : ");
scanf("%s",PRENOM);
fprintf(FICHIER, "%d\n%s\n%s\n", MATRICULE, NOM, PRENOM);
}
// Fermeture du fichier
fclose(FICHIER);
// Ouverture du fichier en lecture
FICHIER = fopen(NOM_FICH, "r");
if (!FICHIER)
{
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", NOM_FICH);
exit(-1);
}
// Affichage du fichier
printf("*** Contenu du fichier %s ***\n", NOM_FICH);
while (!feof(FICHIER))
{
fscanf(FICHIER, "%d\n%s\n%s\n", &MATRICULE, NOM, PRENOM);
printf("Matricule : %d\t", MATRICULE);
printf("Nom et prenom : %s %s\n", NOM, PRENOM);
}

OFPPT/DRIF 64
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

// Fermeture du fichier
fclose(FICHIER);
system("pause");
return 0;
}

Exercice 27 : « récapitulatif »

Ecrire un programme permettant de créer un fichier texte en utilisant les données
structurées et contenant les informations suivantes :

nom[30];
prénom[30];
email[30];
téléphone[10];

Corrigé
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *index; /* pointeur sur FILE */
char nom_fichier[30]; /* nom du fichier */

struct contacts
{ char nom[30];
char prenom[30];

OFPPT/DRIF 65
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

char email[30];
char telephone[10];
};
struct contacts C;
int n;
char s;

do
{
printf("Entrez le nom du fichier : \n");
scanf("%s", nom_fichier);
index = fopen(nom_fichier, "w");
if (!index)
printf("\aERREUR: Impossible d'ouvrir "
"le fichier: %s.\n", nom_fichier);
}while (!index);
printf("Donner le nombre de contacts à saisir : \n");
scanf("%d",&n);
s=getchar();
for (int i=1;i<=n;i++)
{
printf("Donner le nom : ");
gets(C.nom);
printf("Donner le prenom : ");
gets(C.prenom);
printf("Donner l'email : ");
gets(C.email);
printf("Donner le telephone : ");
gets(C.telephone);
fwrite (&C, sizeof(C), 1, index);
}

fclose(index);

index = fopen(nom_fichier, "r");

fread (&C, sizeof(C), 1, index);
while (!feof(index))
{
printf("\n nom : ");
puts(C.nom);
printf("\n prenom : ");
puts(C.prenom);
printf("\n email : ");
puts(C.email);
printf("\n telephone : ");
puts(C.telephone);
fread (&C, sizeof(C), 1, index);
}

fclose(index);
system("pause");
return 0;
}

OFPPT/DRIF 66
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

OFPPT/DRIF 67
Résumé de Théorie et
LANGAGE DE PROGRAMMATION STRUCTUREE
Guide de travaux pratique

1- Liste des références bibliographiques   :

Ouvrage Auteur Edition

Programmer en C Claude DALLANOY EYROLLES

2- Liste des sites web intéressants  :

1- Ma référence : http://www-ipst.u-strasbg.fr/pat/program/tpc.htm

2- Site magnifique (cours exos et solutions!!!) : http://www.ltam.lu/Tutoriel-

Ansi-C/prg-c_c.htm

3- Incontournable site du zéro : http://www.siteduzero.com/tutoriel-3-14189-

apprenez-a-programmer-en-c.html

4- Henri Garreta (très bon polycopié sur C et JAVA)

5- Livre sur Internet : http://fr.wikibooks.org/wiki/Programmation_C/Introduction

6- http://fr.wikibooks.org/wiki/Programmation_C%2B%2B_(d%C3%A9butant)/Notions_de_base

7- Pour comprendre le DEV C++ :

http://www.dil.univmrs.fr/~garreta/generique/autres/UtiliserDevCpp.html

OFPPT/DRIF 68