PROGRAMMATION II
Chap1 : Rappels
1
1 Présentation du langage C
Rappels
• Langage de programmation développé au
cours de l'année 1972 par Dennis Ritchie
et Ken Thompson.
• Un Langage polyvalent permettant le
développement de systèmes d'exploitation,
de programmes applicatifs scientifiques et
de gestion.
• Un Langage structuré.
• Portabilité du code source, due à l'emploi
Ken Thompson (à gauche)
et Dennis Ritchie (à droite).
de bibliothèques dans lesquelles sont
reléguées les fonctionnalités liées à la
machine.
• Grande efficacité et puissance.
2
1 Présentation du langage C
Rappels
Pour pouvoir programmer en C, vous devez
nécessairement avoir installé un compilateur C
sur votre machine.
Après avoir été compilé, le programme peut
être exécuté en chargeant sa version
exécutable en mémoire
Le compilateur est un programme exécutable qui
permet de traduire un programme écrit dans un
langage de programmation en langage machine.
3
1 Présentation du langage C
Rappels
Utilisation des EDI (Environnement de Développement Intégré) pour le développement
des programmes :
• peut être adapté à un langage de programmation particulier ou à plusieurs langages
• comprend en général un éditeur de texte spécialement adapté au langage, un
compilateur un débogueur (outil de mise au point) et un outil de développement
d'interface graphique.
4
1 Structure d’un programme C
Rappels Programme C : composé d’une ou plusieurs fonctions
dont l’une doit s’appeler main
Type de la valeur de retour
int main(void)
{
/* corps du programme*/
déclaration des constantes et des variables ;
instruction1 ;
instruction2 ;
….
}
5
1 Structure d’un programme C
Rappels Programme C : composé d’une ou plusieurs fonctions
dont l’une doit s’appeler main
Nom de la fonction (main signifie principale,
ses instructions sont exécutées)
int main(void)
{
/* corps du programme*/
déclaration des constantes et des variables ;
instruction1 ;
instruction2 ;
….
}
6
1 Structure d’un programme C
Rappels Programme C : composé d’une ou plusieurs fonctions
dont l’une doit s’appeler main
Liste des arguments entre parenthèses
int main(void)
{
void main(void) : La fonction main ne prend aucun paramètre et
ne retourne pas de valeur.
/* corps du programme*/
int main(void) : La fonction main retourne une valeur entière à
déclaration des constantes et des variables ;
l'aide de l'instruction return (0 si pas d’erreur).
instruction1 ;
int main(int arg1, char arg2) : On obtient alors des programmes
auxquels oninstruction2
peut adresser ;des arguments au moment où on lance
le programme. ….
7
1 Structure d’un programme C
Rappels Programme C : composé d’une ou plusieurs fonctions
dont l’une doit s’appeler main
int main(void)
{
Début /* corps du programme*/
déclaration des constantes et des variables ;
instruction1 ;
instruction2 ;
….
} Entre accolades "{" et "}" on
met la succession d‘instructions
Fin à réaliser.(Bloc) 8
1 Structure d’un programme C
Rappels
#include <stdio.h> Directives du préprocesseur :
#define PI 3.14 accès avant la compilation
int fonc_somme(int a, int b);
int fonc_division(int a, int b); Déclaration des fonctions
void main()
{ /* début du bloc de la fonction main*/
int i, j; /* définition des variables locales */
i = 10 ; Programme principal
j=2;
fonc_somme(I,j) ;
fonc_division(i,j) ;
} /* fin du bloc de la fonction main */
int fonc_somme(int a, int b) {
return (a+b);
} Définitions des
fonctions
int fonc_division(int a, intb) {
return (a / b);
9
}
1 Préprocesseur
Rappels
• Le préprocesseur effectue un prétraitement du programme source avant qu'il soit
compilé.
• Ce préprocesseur exécute des instructions particulières appelées directives.
• Ces directives sont identifiées par le caractère # en tête.
Inclusion de fichiers
#include <nom-de-fichier> /* répertoire standard */
#include "nom-de-fichier" /* répertoire courant */
La gestion des fichiers (stdio.h) /* Entrees-sorties standard */
Les fonctions mathématiques (math.h)
Taille des type entiers (limits.h)
Limites des type réels (float.h)
Traitement de chaînes de caractères (string.h)
Le traitement de caractères (ctype.h)
Utilitaires généraux (stdlib.h)
Date et heure (time.h) 10
1 1er programme
Rappels Les caractères précédés de \ sont interprétés
comme suit :
\\ : caractère \
#include <stdio.h> \n : retour à la ligne
\t : tabulateur.
int main(void) \" : caractère "
{
int age; /*déclaration d’une variable*/
printf("Cours de programmation en \t langage C,\n \"SMI-S4\" \n");
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\n ton âge est de %d ans \n",age);
}
11
1 1er programme
Rappels L’utilisation
Format Les de & estprécédés
des caractères
paramètres passés en
delecture
indispensable et scanf
avec
\ sont écriture.
interprétés
(valeur lue etsuit
comme donc: modifiée), pas avec printf
(valeur"%c"
écrite: et
lecture
donc d'unmodifiée).
non caractère.
\\ : caractère \
#include <stdio.h> "%d" ou "%i" : entier
\n : retour signé.
à la ligne
"%e" : réel\t avec un exposant.
: tabulateur.
int main(void) "%f" : réel\"sans exposant.
: caractère "
{ "%o" : le nombre est écrit en base 8.
"%s" : chaîne de caractère.
int age; /*déclaration d’une variable*/
printf("Cours de programmation en \t langage C,\n \"SMI-S4\" \n");
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\n ton âge est de %d ans \n",age);
}
12
1 1er programme
Rappels L’utilisation de & est indispensable avec scanf
(valeur lue et donc modifiée), pas avec printf
(valeur écrite et donc non modifiée).
#include <stdio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Cours de programmation en \t langage C,\n \"SMI-S4\" \n");
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\n ton âge est de %d ans \n",age);
}
13
1 1er programme
Rappels
#include <stdio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Cours de programmation en \t langage C,\n \"SMI-S4\" \n");
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\n ton âge est de %d ans \n",age);
return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
}
14
1 1er programme
Rappels
#include <stdio.h>
int main(void) Cours de programmation en langage C
{ "SMI-S4"
int age; /*déclaration d’une variable*/
printf("Cours de programmation en \t langage C,\n \"SMI-S4\" \n");
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\n ton âge est de %d ans \n",age);
Quel est ton âge ? 18
ton âge est de 18 ans
return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
}
15
1 1er programme
Rappels
#include <stdio.h>
#include <conio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Cours de programmation en \t langage C,\n \"SMI-S4\" \n");
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\n ton âge est de %d ans \n",age);
getch() ; /* Attente d'une saisie clavier */
return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
}
16
1 Les variables
Rappels Déclarations
Syntaxe : Type identificateur1, identificateur2, …,…. ;
Exemple: char c1, c2, c3;
int i, j, var_ent;
Initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{),
void main(void) void main(void)
{ {
char c;
int i,j, k; est équivalent à char c = 'A';
c = 'A'; int i=50,j, k;
i = 50;
j =10; j=k=10;
K=10; 17
1 Types de base sous le langage C
Rappels
4 types de base, les autres types seront dérivés de ceux-ci.
Codage en
Type Signification Exemples de valeur Peut être
mémoire
'a' 'A' 'z' 'Z' '\n' 'a' 'A'
Caractère 1 octet signed,
char 'z' 'Z' '\n'
unique unsigned
Varie de –128 à 127
Short, long,
0 1 -1 4589 32000
int Nombre entier 2 ou 4 octets signed,
-231 à 231 +1
unsigned
Nombre réel 0.0 1.0 3.14 5.32
float 4 octets
simple -1.23
Nombre réel 0.0 1.0E–10 1.0 -
double 8 octets long
double précision 1.34567896 18
1 Les opérateurs en langage C
Rappels Les opérateurs arithmétiques
+ addition
- soustraction
* multiplication
/ division
% modulo (reste de la division entière )
Les opérateurs de comparaison
Les opérateurs logiques
< plus petit
<= plus petit ou égal && et
> plus grand || ou (non exclusif)
>= plus grand ou égal ! non
== égal
!= différent
19
1 Incrément et décrément
Rappels
• C a deux opérateurs spéciaux pour incrémenter (ajouter 1) et
décrémenter (retirer 1) des variables entières
++ increment
-- decrement
• Ces opérateurs peuvent être préfixés (avant la variable) ou postfixés
(après)
i++ est équivalent à i = i + 1 ou i += 1
20
1 Incrément et décrément
Rappels
Préfixe et Postfixe
#include <stdio.h>
int main(void)
{ équivalent à:
int i, j = 5; 1. j++;
2. i = j;
i=6, j=6
i = ++j;
printf("i=%d, j=%d\n", i, j);
j = 5; équivalent à:
i = j++; 1. i = j; i=5, j=6
printf("i=%d, j=%d\n", i, j); 2. j++;
return 0;
} 21
1 Les structures de contrôle en C
Rappels
Alternative: if-else
Choix Multiple: switch-case
Itérations: for, while, do-while
Rupture de Contrôle: break, continue, return … goto
22
1 Les structures de contrôle en C
Rappels
Les decisions : if - else
if (expression booléenne vraie) if (a<b)
{ {
BLOC 1 D'INSTRUCTIONS min=a;
} }
else else
{ {
BLOC 2 D'INSTRUCTIONS min=b;
} }
Le bloc "else" est optionnel.
23
1 Les structures de contrôle en C
Rappels
Les decisions : if - else
if (i == 10) i++; == et pas =
La variable i ne sera incrémentée que si elle est égale à 10.
if (!recu) printf ("rien reçu\n");
Le message "rien reçu" est affiché si recu vaut zéro.
Si plusieurs instructions, il faut les mettre entre accolades :
if ((!recu) && (i < 10) && (n!=0) )
{
if(delta != 0) équivaut à if(delta)
i++; if(delta == 0) équivaut à if(!delta)
moy = som/n;
printf(" la valeur de i =%d et moy=%f\n", i,moy) ;
}
else
{
printf ("erreur \n");
i = i +2; // i +=2 ;
} 24
1 Les structures de contrôle en C
Rappels
if emboîtés
else est associé avec le if le plus proche
int i = 100;
if(i > 0)
if(i > 1000)
printf("i > 1000\n");
else
printf("i inférieur à 1000\n");
i inférieur à 1000
25
1 Les structures de contrôle en C
Rappels Les boucles :
Les itérations – for
int i,j;
Syntaxe en C:
for( init ; test; increment) for (i = 0; i <3; i++) {
printf ( "i = %d\n", i); i=0
{ i=1
/* corps de for */ }
i=2
} for(j = 5; j > 0; j--)
j=5
printf("j = %d\n", j); j=4
j=3
j=2
j=1
26
1 Les structures de contrôle en C
Rappels Les boucles :
TANT QUE … FAIRE…
WHILE
Syntaxe en C:
while (expression)
{ Exemple
............; /* bloc d'instructions */
............;
............;
}
Le test se fait d'abord, le bloc d'instructions
n'est pas forcément exécuté.
Rq: les {} ne sont pas nécessaires lorsque le
bloc ne comporte qu'une seule instruction.
27
1 Les structures de contrôle en C
Rappels Les boucles :
TANT QUE … FAIRE…
WHILE
Syntaxe en C: Interieur 1
Interieur 2
while (expression) Interieur 3
{ Exemple Interieur 4
............; /* bloc d'instructions */ Exterieur 5
............; i=1;
............; while(i<5)
} {
Le test se fait d'abord, le bloc d'instructions
printf(“Interieur %d\n",i);
n'est pas forcément exécuté. i++;
}
Rq: les {} ne sont pas nécessaires lorsque le printf("Exterieur %d\n",i);
bloc ne comporte qu'une seule instruction.
28
1 Les structures de contrôle en C
Rappels Les boucles :
REPETER … TANT QUE
do while
Syntaxe en C:
do
{
............; /* bloc
d'instructions */
............;
}
while (expression);
(guarantit l’exécution au moins une fois)
29
1 Les structures de contrôle en C
Rappels Les boucles :
REPETER … TANT QUE
do while
Syntaxe en C: j=5
j=4
do
Exemple j=3
{ j=2
............; /* bloc int j = 5; j=1
d'instructions */ stop
............;
do
} printf("j = %i\n", j--);
while (expression); while(j > 0);
printf("stop\n");
(guarantit l’exécution au moins une fois)
30
1 Les structures de contrôle en C
Rappels Choix multiples
AU CAS OU… FAIRE : switch-case
switch(variable de type char ou int) /* au cas où la variable vaut: */
{
case valeur1: ......; /* cette valeur1(étiquette): exécuter ce bloc d'instructions.*/
.......;
break; /* L'instruction d'échappement break;
permet de quitter la boucle ou l'aiguillage le plus proche.
*/
case valeur2:........; /* cette valeur2: exécuter ce bloc d'instructions.*/
........;
break;
.
. /* etc ...*/
.
default: .......; /* aucune des valeurs précédentes: exécuter ce bloc
........; d'instructions, pas de "break" ici.*/
} 31
1 Les structures de contrôle en C
Rappels Choix multiples
AU CAS OU… FAIRE : switch-case
main( )
{ char c;
switch (c) {
case 'b':
case 'm':
case 'g':
case 'y': printf("voyelle\n");
break ;
default : printf("consonne\n");
}
}
32
1 Les structures de contrôle en C
Rappels Instructions d'échappement
Pour rompre le déroulement séquentiel d'une suite d'instructions
BREAK: permet d’arrêter le CONTINUE : permet l’abandon de l’itération
déroulement de la boucle et le courante et le passage à l’itération suivante
passage à l’instruction qui la suit
int i, j=1; for (i = -10; i <= 10; i++)
char a; {
for (i = -10; i <= 10; i++){ if (i == 0)
continue;
while(j!=0) /* boucle infinie */ // pour éviter la division par zéro
{ printf(“ %f”, 1 / i);
a=getchar(); }
if(a= ='x')
break;
} return (expression);
} permet de sortir de la fonction qui la contient
En cas de boucles imbriquées, break ne met
fin qu’ à la boucle la plus interne 33
1 Les structures de contrôle en C
Rappels Instructions d'échappement
#include <stdio.h>
void main()
goto étiquette
{
int i, j;
for (i=0; i < 10; i++)
if ( i>4 )
goto trouve;
i++;
j+=i;
trouve:
printf(“ la valeur de i est %d\n",i);
34
}
1 Les tableaux
Rappels Déclaration de tableaux
• Un tableau (array) est une collection de variables de même type, appelées éléments
• On les déclare par un type, un nom et une dimension (CONSTANTE) placée entre [ ]
• Le langage C alloue toujours un tableau dans une zone contigüe de la mémoire
• Une fois déclaré, on ne peut redimensionner un tableau
Exemples
int tab[4]; déclare un tableau de 4 valeurs entières tab[0] tab[1] tab[2] tab[3]
float A[5] = { 10.1, 20.3, 30.5, 40.0, 50.4 };
35
1 Les tableaux
Rappels Accès aux éléments d’un tableau
void main(void) a
{ 59 0
int a[6];
? 1
int i = 7;
? 2
a[0] = 59; 2 3
a[5] = -10;
a[i/2] = 2; ? 4
-10 5
a[6] = 0;
a[-1] = 5;
}
Les tableaux consomment beaucoup
de place mémoire. On a donc intérêt
à les dimensionner au plus juste. 36
1 Les tableaux
Rappels Accès aux éléments d’un tableau
void main(void) a void main(void)
{ 59 0
int a[6]; {
? 1
int i = 7;
int i;
? 2
a[0] = 59; 2 3 int A[6] = { 1, 2,3, 5, 7, 11 };
a[5] = -10;
a[i/2] = 2; ? 4 for (i=0;i<6;i++)
-10 5 printf("%d ", A[i]);
a[6] = 0;
a[-1] = 5; }
}
Les tableaux consomment beaucoup
de place mémoire. On a donc intérêt
à les dimensionner au plus juste. 37
1 Les tableaux
Rappels Accès aux éléments d’un tableau
void main()
void main(void) a
{
{ 59 0
int a[6];
?
const int N=10;
1
int i = 7;
? 2 int t[N],i;
a[0] = 59; 2 3 for (i=0;i<N;i++)
a[5] = -10;
a[i/2] = 2; ? 4 {
-10 5
a[6] = 0; printf("Entrez t[%d]=",i);
a[-1] = 5; scanf("%d",&t[i]);
}
}
Les tableaux consomment beaucoup
}
de place mémoire. On a donc intérêt
à les dimensionner au plus juste. 38
1 Les tableaux
Rappels Exemple :
Calcul du nombre d'étudiants ayant une note supérieure à 10
main ( )
{ float notes[30];
int nbre,i;
for(i=0;i<30;i++)
{ printf ("Entrez notes[%d] \n ",i);
scanf(" %f" , ¬es[i]);
}
nbre=0;
for (i=0; i<30; i++)
if (notes[i]>10) nbre+=1;
printf (" le nombre de notes > à 10 est égal à : %d", nbre);
}
39
1 Les tableaux
Rappels Tableaux à plusieurs dimensions
On peut définir un tableau à n dimensions de la façon suivante:
Type Nom_du_Tableau[D1][D2]…[Dn];
où Di est le nombre d’éléments dans la dimension i
Exemple : pour stocker les notes de 20 étudiants en 5 modules dans deux
examens, on peut déclarer un tableau :
float notes[20][5][2];
(notes[i][j][k] est la note de l’examen k dans le module j pour l’étudiant i)
40
1 Les tableaux
Rappels Tableaux à deux dimensions (Matrices)
Syntaxe : Type nom_du_Tableau[nombre_ligne][nombre_colonne];
Ex: short A[2][3]; On peut représenter le tableau A de la manière suivante :
• Un tableau à deux dimensions A[n][m] est à interpréter comme un tableau
unidimensionnel de dimension n dont chaque composante tableau
unidimensionnel de dimension m.
• Un tableau à deux dimensions A[n][m]contient n* m composantes. Ainsi lors de
la déclaration, on lui réserve un espace mémoire dont la taille (en octets)
41
est
égal à : n*m* taille du type
1 Les tableaux à deux dimensions
Rappels Initialisation à la déclaration d’une matrice
L’initialisation lors de la déclaration se fait en indiquant la liste des valeurs
respectives entre accolades ligne par ligne
Exemple :
float A[3][4] = {{-1.5, 2.1, 3.4, 0}, {8, 7e-5,1, 2.7 }, {3.1, 0, 2.5E4, -1.3E2}};
A[0][0]=-1.5 , A[0][1]=2.1, A[0][2]=3.4, A[0][3]=0
A[1][0]=8 , A[1][1]=7e-5, A[1][2]=1, A[1][3]=2.7
A[2][0]=3.1 , A[2][1]=0, A[2][2]=2.5E4, A[2][3]=-1.3E2
42
1 Les tableaux à deux dimensions
Rappels Matrices : saisie et affichage
• Saisie des éléments d’une matrice d’entiers A[n][m] :
for(i=0;i<n;i++)
for(j=0;j<m;j++)
{ printf ("Entrez la valeur de A[%d][%d] \n ",i,j);
scanf(" %d" , &A[i][j]);
}
• Affichage des éléments d’une matrice d’entiers A[n][m] :
for(i=0;i<n;i++)
{ for(j=0;j<m;j++)
printf (" %d \t",A[i][j]);
}
43
1 Les tableaux à deux dimensions
Rappels Exercice 1
Ecrire un programme qui construit et affiche une matrice carrée
unitaire U de dimension N (max 50).
Une matrice unitaire est une matrice, telle que:
Uij = 1 si i=j
sinon Uij = 0
44
1 Les tableaux à deux dimensions
Rappels Exercice 1 : correction
#include <stdio.h>
main()
{
/* Déclarations */
int U[50][50]; /* matrice unitaire */
int N; /* dimension de la matrice unitaire */
int I, J; /* indices courants */
/* Saisie des données */
printf("Dimension de la matrice carrée (max.50) : ");
scanf("%d", &N);
45
1 Les tableaux à deux dimensions
Rappels /* Construction de la matrice carrée unitaire */
for (I=0; I<N; I++)
for (J=0; J<N; J++)
if (I==J)
U[I][J]=1;
else
U[I][J]=0;
/* Edition du résultat */
printf("Matrice unitaire de dimension %d :\n", N);
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("%d", U[I][J]);
printf("\n");
}
return 0;
} 46
1 Exercice 2
Rappels
Ecrire un programme effectuant le décalage des éléments
d'un tableau.
Exemple :
Tableau
D E C A L A G E
initial
Tableau
E C A L A G E D
modifié
47
1 Exercice 3
Rappels
Ecrire un programme qui teste si une matrice carrée d’ordre
n est symétrique et qui retourne « la matrice M est
symétrique » ou « la matrice M n’est pas symétrique ».
49
1 Exercice 4
Rappels
Ecrire un programme qui lit la dimension N d'un tableau T
du type int (dimension maximale: 50 composantes), remplit
le tableau par des valeurs entrées au clavier et affiche le
tableau.
Copiez ensuite toutes les composantes strictement
positives dans un deuxième tableau TPOS et toutes les
valeurs strictement négatives dans un troisième tableau
TNEG. Afficher les tableaux TPOS et TNEG.
51