Qu'est-ce qu'un bon programme?

Un Bon Programme ? ? :

Les bases de Il doit résoudre le PROBLEME !

programmation en langage C Efficacité Rapidité?

INSTANTANE ! DUREE DE VIE ?

- Lisible
- Structuré

ProgrammationC 1
ProgrammationC 2

Objectifs Qualités attendues d'un programme

 Être capable de bien programmer;

 Comprendre les différentes constructions de

 Clarté
la programmation en C;  Simplicité
 Efficacité
 Savoir programmer de manière modulaire.  Modularité
 Extensibilité

ProgrammationC 3 ProgrammationC 4

TYPE de la valeur de retour

Types de base "main" : Cela signifie "principale",

ses instructions sont exécutées.
4 types de base, les autres types seront dérivés de ceux-ci.
int main(void)
Type Exemples de valeur Codage en Peut être {
Signification void main(void): La fonction main ne prend
mémoire /* corps du programme*/
begin aucun paramètre et ne retourne pas de valeur.
'a' 'A' 'z' 'Z' '\n' 'a' 'A' declaration des Cstes et Var ;
1 octet signed, int main(void): La fonction main retourne une
char Caractère unique 'z' 'Z' '\n' instruction1 ;
unsigned valeur entière à l'aide de l'instruction return (0 si
Varie de –128 à 127 instruction2 ; pas d’erreur).
Short, long, ….
0 1 -1 4589 32000 int main(int argc, char *argv[]): On obtient alors
int Nombre entier 2 ou 4 octets signed, }
-231 à 231 +1 des programmes auxquels on peut adresser des
unsigned end arguments au moment où on lance le programme.
Nombre réel 0.0 1.0 3.14 5.32
float 4 octets
simple -1.23 Entre accolades "{" et "}" on
mettra la succession d'actions à
Nombre réel 0.0 1.0E–10 1.0 - réaliser.(Bloc)
double 8 octets long
double précision 1.34567896

ProgrammationC 5 ProgrammationC 6

1
 Structure d'un programme C Indenter = lisibilté #include <Lib1.h>
#include <stdio.h> #include <Lib2.h>
#define DEBUT -10 Directives du préprocesseur :
Prenez l'habitude de respecter (au moins au début) les #define X 0;
#define FIN 10 accès avant la compilation
règles :
#define MSG "Programme de démonstration\n" int fonc1(int x);
int fonc1(int x); - une accolade est seule sur sa ligne, float fonc2(char a);
int fonc2(int x); Déclaration des fonctions
- { est alignée sur le caractère de gauche de la ligne
précédente, int main(void)
void main()
{ /* début du bloc de la fonction main*/ - } est alignée avec l'accolade ouvrante correspondante, { /*main*/
int i; /* définition des variables locales */
Programme instruction;
- après { , on commence à écrire deux caractères plus à
i=0; principal instruction;
droite.
fonc1(i) ;
{
fonc2(i) ;
} /* fin du bloc de la fonction main */ instruction;

int fonc1(int x) { Fonctionnement : {

return x; Définitions des instruction;
}
fonctions - Taper et sauvegarder le programme,
- Compiler le programme, }
int fonc2(int x) { - Exécuter le programme. }
return (x * x);
} instruction;

ProgrammationC 7 ProgrammationC
} /* fin main*/ 8

Préprocesseur
Le préprocesseur effectue un prétraitement du programme source avant qu'il soit compilé.
1er Programme
Ce préprocesseur exécute des instructions particulières appelées directives.
Ces directives sont identifiées par le caractère # en tête. #include <stdio.h>
Inclusion de fichiers #include <conio.h>
#include <nom-de-fichier> /* répertoire standard */ int main(void)
#include "nom-de-fichier" /* répertoire courant */ {

printf(" BTS SE "); BTS SE

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)
getch() ; /* Attente d'une saisie clavier */
Traitement de chaînes de caractères (string.h)
return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
Le traitement de caractères (ctype.h)
Utilitaires généraux (stdlib.h) }
Date et heure (time.h)

ProgrammationC 9 ProgrammationC 10

La fonction printf() : Les constantes de type caractère ont une valeur entiére dans la table ASCII

Librairie : stdio.h. #include <stdio.h> char c1 = 'A',

c2 = '\x41'; /* représentation hexadécimale */
Syntaxe : int printf( const char *format [, arg [, arg]...]);

Description : Permet l'écriture formatée (l'écran par défaut).

caractères nom symbole code hexa décimal
Exemple : \n newline LF 10
printf("Qu'il est agreable d’utiliser printf "
"en\t C,\nlorsqu'on l'utilise \"proprement\".\n"); \t tabulation HT 9
\b backspace BS 8
Résultat sur la sortie :
Qu'il est agreable d’utiliser printf en C, \r return CR 13
lorsqu'on l'utilise "proprement". \f form feed FF 12
Les caractères précédés de \ sont interprétés comme suit : \\ backslash 5C 92
\\ : caractère \ \' single quote 27 39
\n : retour à la ligne
\t : tabulateur. \" double quote 22 34
\" : caractère "
\r : retour chariot
ProgrammationC 11 ProgrammationC 12

2
 La fonction scanf() : 1er Programme
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int scanf(const char *format [argument, ...]); #include <stdio.h>

#include <conio.h>
Description : Lit à partir de stdin (clavier en principe), les différents int main(void)
{
arguments en appliquant le format spécifié. int age; /*déclaration d’une variable*/
Exemple : scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
! printf("Je te souhaite le bon"
"jour aux TP\nEt je t"
L’utilisation de & est indispensable avec
Format des paramètres passés en lecture et écriture. scanf (valeur lue et donc modifiée), pas avec
"e souhaite bon trav"
printf (valeur écrite et donc non modifiée).
"ail\n");
"%c" : lecture d'un caractère.
"%d" ou "%i" : entier signé. !
printf("Quel est ton âge? ");
"%e" : réel avec un exposant. scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
"%f" : réel sans exposant. printf("\nAlors ton age est de %d ans!\n",age);
"%g" : réel avec ou sans exposant suivant les besoins.
"%G" : identique à g sauf un E à la place de e. getch() ; /* Attente d'une saisie clavier */
"%o" : le nombre est écrit en base 8. return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
"%s" : chaîne de caractère. }
Quel est ton âge ? 18
"%u" : entier non signé.
"%x" ou "%X" : entier base 16 avec respect majuscule/minuscule. Alors ton age est de 18 ans!
ProgrammationC 13 ProgrammationC 14

Variables : déclarations ! scanf

Syntaxe : Type identificateur1, identificateur2, …,…. ;
Exemples entrées résultats
Exemple: char c1, c2, c3;
int i, j, var_ent; char c1, c2, c3;
scanf(‘’%c%c%c‘’,&c1,&c2,&c3);
abc c1=a c2=<espace> c3=b
Variables : initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{), c1=a c2=b c3=c
scanf(‘’ %c %c %c‘’,&c1,&c2,&c3);
zone des déclarations:

void main(void) void main(void)

{ {
est équivalent à
char c; char c = 'A'; char c;
int i,j, k; int i;
c = 'A'; int i=50,j, k;
float x;
i = 50; j=k=10;
j =10; = opérateur d’affectation
scanf(‘’%2d %5f %c‘’,&i,&x,&c); 12 123.567 r i=12 x=123.5 c=6
K=10;

ProgrammationC
Cette règle s'applique à tous : char, int, float ... 15 ProgrammationC 16

Affichages et saisies LES DECLARATIONS DE CONSTANTES

Librairie : stdio.h 1ere méthode : définition d'un symbole à l'aide de la directive de compilation #define.
Fonction Syntaxe Description
Le compilateur ne réserve pas
Écriture formatée
Exemple: #define PI 3.14159 de place en mémoire
printf printf( const char *format [, arg [,
arg]...]); : sortie standard void main()
{
scanf scanf( const char *format [, arg [, Lecture formatée
arg]...]); 7 entrée standard float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
putchar putchar(int c); Écrire le caractère c
: ....
}
getchar getchar(); Lecture d'un caractère
getch(); <conio.h> 7
getch Syntaxe : #define identificateur texte(valeur) !
puts *puts(char *s); Ecriture/Lecture d'une
chaîne de caractères, Les identificateurs s'écrivent
*gets(char *s); #define TAILLE 100
gets terminée par \n traditionnellement en
#define MAXI (3 * TAILLE + 5) majuscules, mais ce n'est pas
sprintf sprintf(char *s, char *format, arg ...); Ecrit dans la chaîne
d'adresse s. #define nom_macro(identif_p1 , ... ) texte une obligation.
#define SOMME(X,Y) X+Y
sscanf sscanf(char *s, char *format, pointer Lit la chaîne d'adresse s.
#define MULTIP(A,B) (A)*(B)
...);

ProgrammationC 17 ProgrammationC 18

3
 LES DECLARATIONS DE CONSTANTES
Identificateurs
2eme méthode : déclaration d'une variable, dont la valeur sera constante pour tout le programme. Les identificateurs nomment les objets C (fonctions, variables ... )

C'est une suite de lettres ou de chiffres.

Le premier caractère est obligatoirement une lettre.
Exemple: Le caractère _ (souligné) est considéré comme une lettre.
void main() Le compilateur réserve de la Reconnaissance suivant les 31 premiers caractères.
{ place en mémoire (ici 4 octets).
const float PI = 3.14159; Le C distingue les minuscules des majuscules.
const int JOURS = 5;
float perimetre,rayon = 8.7; Exemples :
perimetre = 2*rayon*PI; abc, Abc, ABC sont des identificateurs valides et tous différents.
.... /*ERREUR !*/ On ne peut
JOURS = 3; changer la valeur d’une const. Identificateurs valides :
.... ! xx y1 somme_5 _position
Noms surface fin_de_fichier VECTEUR
}
Identificateurs invalides :
3eme commence par un chiffre
x#y caractère non autorisé (#)
no-commande caractère non autorisé (-)
taux change caractère non autorisé (espace)
ProgrammationC 19 ProgrammationC 20

Les opérateurs arithmétiques

Un identificateur ne peut pas être un mot réservé du langage :
 Le C propose les opérateurs suivants :

auto double int struct + addition

break else long switch - soustraction
case enum register typedef * multiplication
char extern return union / division
const float short unsigned
% modulo (reste de la division entière )
continue for signed void
default goto sizeof volatile % ne peut être utilisé qu'avec des entiers
do if static while

7/2 3


Remarque : Les mots réservés du langage 7.0/2
C doivent être écrits en minuscules. 7/2.0 3.5
7.0/2.0

ProgrammationC 21 ProgrammationC 22

Les opérateurs de comparaison

Utiliser des opérateurs arithmétiques
< plus petit Le type booléen
<= plus petit ou égal n'existe pas. Le
Le compilateur considère le type des opérandes résultat d'une
pour savoir comment effectuer les opérations > plus grand expression logique
vaut 1 si elle est
>= plus grand ou égal
vraie et 0 sinon.
k= 5/4 = 1 void main(void) == égal
{ !
!= différent
int i = 5, j = 4, k; Réciproquement,
h = 5.0/4.0 = 1.25 double f = 5.0, g = 4.0, h; toute valeur non
Les opérateurs logiques nulle est considérée !
k = i / j; && et comme vraie et la
h = f / g; valeur nulle comme
h = i / j; || ou (non exclusif) fausse.
h = 5/4 = 1.0000
} ! non

ProgrammationC 23 ProgrammationC 24

4
 int i;
Exemple
float f;
char c;
Contractions d'opérateurs
i = 7; f = 5.5; c = 'w';  Il y a une famille d’opérateurs
f>5 ====> vrai (1) += -= *= /= %=
(i + f) <= 1 ====> faux (0)
c == 'w‘ ====> vrai (1)
&= |= ^=
c != 'w' ====> faux (0) <<= >>=
c >= 10*(i + f) ====> faux (0)
(i >= 6) && (c == 'w') ====> vrai (1)  Pour chacun d’entre eux
(i >= 6) || (c == 119) ====> vrai (1)
!expr1 est vrai si expr1 est faux et faux si expr1 est vrai ; expression1 op= expression2
expr1&&expr2 est vrai si les deux expressions expr1 et expr2 sont vraies et
faux sinon. L'expression expr2 n'est évaluée que dans le cas où l'expression
est équivalent à:
expr1 est vraie ; (expression1) = (expression1) op (expression2)
expr1 || expr2 = (1) si expr1=(1) ou expr2=(1) et faux sinon. a += 32; f /= 9.2; i *= j + 5;
L'expression expr2 n'est évaluée que dans le cas où l'expression expr1
a = a + 32; f = f / 9.2; i = i * (j + 5);
est fausse.
ProgrammationC 25 ProgrammationC 26

Incrément et décrement Préfixe et Postfixe

#include <stdio.h>
 C a deux opérateurs spéciaux pour incrémenter (ajouter 1)
et décrémenter (retirer 1) des variables entières int main(void)
{
++ increment : i++ ou ++i est équivalent à i += 1 ou i = i + 1 int i, j = 5;
équivalent à:
1. j++;
-- decrement
i = ++j;
2. i = j; !
 Ces opérateurs peuvent être préfixés (avant la variable) ou printf("i=%d, j=%d\n", i, j);
postfixés (après)
j = 5; équivalent à:
int i = 5, j = 4; i = j++; 1. i = j;
“i” vaudra 6 printf("i=%d, j=%d\n", i, j); 2. j++; !
i++;
“j” vaudra 3 return 0;
--j; } i=6, j=6
++i; i=5, j=6
“i” vaudra 7
ProgrammationC 27 ProgrammationC 28

Les Conversions de types

Le langage C permet d'effectuer des opérations de conversion de type.
On utilise pour cela l'opérateur de "cast" ().
Les structures de contrôle en C
#include <stdio.h>
#include <conio.h>
void main() Conversion float -> int: 89.67 -> 89
Alternative: if-else
{
Conversion int -> float: 4660 -> 4660.00
int i=0x1234, j; Choix Multiple: switch-case
char d,e; Conversion int -> char: 1234 -> 34
float r=89.67,s; Conversion float -> char: 89.67 -> 89 Itérations: for, while, do-while
j = (int)r;
Pour sortir frapper une touche
s = (float)i;
d = (char)i;
Rupture de Contrôle: break, continue, return …
e = (char)r; goto
printf("Conversion float -> int: %5.2f -> %d\n",r,j);
printf("Conversion int -> float: %d -> %5.2f\n",i,s);
printf("Conversion int -> char: %x -> %x\n",i,d);
printf("Conversion float -> char: %5.2f -> %d\n",r,e);
printf("Pour sortir frapper une touche ");
getch(); // pas getchar
}
ProgrammationC 29 ProgrammationC 30

5
 Exemples :
Les structures de contrôle en C
if (i < 10) i++;
La variable i ne sera incrémentée que si elle a une valeur inférieure à 10.
Les décisions: if else
if (i == 10) i++; == et pas =
if (expression booléenne vraie) if (a<b) La variable i ne sera incrémentée que si elle est égale à 10.
{ {
if (!recu) printf ("rien reçu\n");
BLOC 1 D'INSTRUCTIONS min=a; Le message "rien reçu" est affiché si recu vaut zéro.
} }
else else if ((!recu) && (i < 10)) i++;
Le bloc " else " { { i ne sera incrémentée que si recu vaut zéro et i<10.
est optionnel. BLOC 2 D'INSTRUCTIONS min=b;
Si plusieurs instructions, il faut les mettre entre accolades.
} }

=
if ((!recu) && (i < 10) && (n!=0) ){
* Tout ce qui est 0 ( ‘\0’ 0 0.0000 NULL ) est faux i++; if(delta != 0) if(delta)
* Tout ce qui est != de 0 ( 1 ‘0’ 0.0001 1.34 ) est vrai moy = som/n;

=
printf(" la valeur de i =%d et moy=%f\n", i,moy) ;
if(32) } if(delta == 0) if(!delta)
printf("ceci sera toujours affiche\n"); else {
if(0) printf ("erreur \n");
i = i +2; // i +=2 ;
printf("ceci ne sera jamais affiche\n");
} !
ProgrammationC 31 ProgrammationC 32

! Attention! if emboîtés
 else est associé avec le if le plus proche
 Ne pas confondre = = (opérateur logique d’égalité)
int i = 100;
et = (opérateur d’affectation)
if(i > 0)
#include <stdio.h> if(i > 1000)
printf("i > 1000\n");
int main(void)
{ else
int i = 0; printf("i is reasonable\n"); i is reasonable
if(i = 0) /* ici affectation */
int i = 100;
printf("i = zero\n");
else
printf(“Quand i != de zero\n"); if(i > 0) {
if(i > 1000)
return 0;
printf(" i > 1000 \n");
}
Quand i != de zero } else
printf("i is negative\n"); I is negative

ProgrammationC 33 ProgrammationC 34

Les itérations – for LA BOUCLE TANT QUE ... FAIRE ...

int i,j;
for( init ; test; increment) i=0 Boucle pré-testée
{ for (i = 0; i <3; i++) { i=1
/* corps de for */ printf ( "i = %d\n", i); i = 2 Il s'agit de l'instruction while : tant que, pas jusqu’à ce que!
} j=5 tant que (expression vraie)
} j=4
for(j = 5; j > 0; j- -) faire{BLOC D'INSTRUCTIONS}
printf("j = %d\n", j); j = 3
double angle; j=2 Syntaxe en C:
j=1 Organigramme:
while (expression)
for(angle = 0.0; angle < 3.14159; angle += 0.2)
{
printf("sine of %.1lf is %.2lf\n",angle, sin(angle));
............; /* bloc d'instructions */
int i, j, k; ............;
............;
for(i = 0, j = 2, k = -1; (i < 20) &&(j==2); i++, k--) }
for( ; ; )
Le test se fait d'abord, le bloc d'instructions
{
n'est pas forcément exécuté.
............; /* bloc d'instructions */
............; Rq: les {} ne sont pas nécessaires lorsque le
............; bloc ne comporte qu'une seule instruction.
}

est une boucle infinie (répétition infinie du bloc d'instructions).

ProgrammationC 35 ProgrammationC 36

6
 Exemple
Intérieur 1
do while = REPETER … tant que
i=1;
while(i<5) Intérieur 2 (guarantit l’exécution au moins une fois)
{ Intérieur 3
Intérieur 4 bloc d' do
printf(“Intérieur %d\n",i); {
itération i++; Extérieur 5 instructions ............; /* bloc d'instructions */
} ............;
printf("Extérieur %d\n",i); }
while (expression);
int j = 5; non
condition
start oui vraie
tant que, pas jusqu’à ce que! printf("start\n"); end
while(j == 0)
printf("j = %d\n", j--);
suite du programme i=1;
printf("end\n");
i=1; do
int j = 5; { i=1
while(i<5); do j=5 printf(“i=%d ",i);
{ stop
"tant que l'expression est vraie printf("j = %i\n", j--); j = 4 i++;
printf(“Intérieur %d\n",i); attendre". while(j > 0); j=3 }while(i<0);
i++; printf("stop\n"); j=2 printf("stop\n");
} j=1
stop
ProgrammationC 37 ProgrammationC 38

Cette instruction est commode pour les "menus":

switch = AU CAS OU ... FAIRE ...
char choix; int choix;
switch(variable de type char ou int) /* au cas où la variable vaut: */ printf("SAISIE TAPER 1\n");
{ printf("AFFICHAGE TAPER 2\n"); float f;
case valeur1: ......; /* cette valeur1(étiquette): exécuter ce bloc d'instructions.*/ printf("POUR SORTIR TAPER S\n");
.......;
break; /* L'instruction d'échappement break;
printf("\nVOTRE CHOIX: "); scanf(" %d ", &choix); switch(f) {
permet de quitter la boucle ou l'aiguillage le plus proche. choix = getchar(); case 2:
switch(choix)
*/ switch(choix) ....
{ {
case valeur2:........; /* cette valeur2: exécuter ce bloc d'instructions.*/ case '1': .......; case 1: … switch(i) {
........;
break;
break; ! case 2 * j:
....
. case '2': ......;
. /* etc ...*/
.
break;
default: .......; /* aucune des valeurs précédentes: exécuter ce bloc
........; d'instructions, pas de "break" ici.*/ case 'S': printf("\nFIN DU PROGRAMME ....");
} break;

Le bloc "default" n'est pas obligatoire. valeur1, valeur2, …. doivent être des expressions default; printf("\nCE CHOIX N'EST PAS PREVU "); /* pas de break ici */
constantes. L’instruction switch correspond à une cascade d’instructions if ...else }

ProgrammationC 39 ProgrammationC 40

goto étiquette
Instructions d'échappement
#include <stdio.h>
Pour rompre le déroulement séquentiel d'une suite d'instructions void main()
{
Break;
# Continue; 8 int i, j;
int i, j=1; for (i = -10; i <= 10; i++) for (i=0; i < 10; i++)
char a; {
for (i = -10; i <= 10; i++){ if (i == 0) for (j=0; j < 4; j++) {
continue; if ( (i*j) == 10)
while(j!=0) /* boucle infinie */ // pour éviter la division par zéro
{ printf(“ %f”, 1 / i); goto trouve;
a=getchar(); } printf("i*j != 10.\n");
if(a= ='x')
break; }
} return (expression);
trouve:
} permet de sortir de la fonction qui la contient
printf("i*j =%d * %d = %d== 10.\n",i,j,i*j);

exit (expression); La fonction est interrompu. }

Si x est tapée au clavier expression : un entier indiquant le code de terminaison
du processus
ProgrammationC 41 ProgrammationC 42