Qu'est-ce qu'un bon programme?

Un Bon Programme ? ? :

Il doit résoudre le PROBLEME !

Efficacité Rapidité?

INSTANTANE ! DUREE DE VIE ?

- Lisible
- Structuré

2
 Objectifs
 Être capable de bien programmer

 Comprendre les différentes constructions de

la programmation en C

 Savoir programmer de manière modulaire

3
Qualités attendues d'un
programme

 Clarté
 Simplicité
 Efficacité
 Modularité
 Extensibilité

4
 Introduction au Langage
C,C++
 Mon Premier Programme en C

Début du programme

Inclusion de la bibliothèque
#include <stdio.h>
contenant la fonction printf

void main() Point d'entré du programme

{
printf("Bonjour!\n"); première
instruction
}
Fin du programme
5
Introduction au Langage
C,C++
 Définition d'une variable
 nom:
 Unique pour chaque variable
 Commence toujours par une lettre
 Différenciation minuscule-majuscule
 type:
 Conditionne le format de la variable en
mémoire
 Peut être soit un type standard ou un type
utilisateur
 valeur:
 Peut évoluer pendant l'exécution
 initialisation grâce à l'opérateur
d'affectation
6
Introduction au Langage C
 Types de variable
 charcaractères
 int entiers
 short [int] entiers courts
 long [int] entiers longs
 float nombres décimaux
 double nombres décimaux de
précision
supérieure
 long double nombres décimaux
encore plus
précis
 unsigned int entier non signé
7
Introduction au Langage
C,C++
 Déclaration d'une variable
 Type nom_de_la_variable [=
valeur]
 Exemple:
 int nb;
 float pi = 3.14;

 char c = 'a';

 long i,j,k;

 double r = 6.2879821365;

8
Comment représenter les choses ?
 Le codage de l’information
 Avec 2 bit on peut coder 4 éléments
 00 – 01 – 10 – 11
 Avec 1 octet on peut coder 28 éléments
 Cela permet par exemple
 De représenter les nombres entier de 0 à 255
 De représenter 256 symboles comme les caractères utilisés
dans une langue.
• Le code autrefois le plus répandu pour représenter lettre,
chiffre, symbole est le code ASCII (American Standard Code
for Information Interchange ). Il a été standardisé de manière
universelle sur 7 bits et ne permet pas de coder les lettres
accentuées ni les caractères spéciaux du français ç, ù, €…
L’emploi d’un 8ième bit a été utilisé pour ces caractères mais
dans un codage non universel ce qui explique encore
aujourd'hui certains problèmes de compatibilités observés
entre Macintosh, PC et Unix.
9
Types de base
4 types de base, les autres types seront dérivés de ceux-ci.

Type Exemples de valeur Codage en Peut être

Signification
mémoire
'a' 'A' 'z' 'Z' '\n' 'a' 'A'
1 octet signed,
char Caractère unique 'z' 'Z' '\n'
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

10
 TYPE de la valeur de retour

"main" : Cela signifie "principale",

ses instructions sont exécutées.

int main(void)
{
void main(void): La fonction main ne prend
/* corps du programme*/
begin aucun paramètre et ne retourne pas de valeur.
declaration des Cstes et Var ;
instruction1 ; int main(void): La fonction main retourne une
valeur entière à l'aide de l'instruction return (0
instruction2 ; si pas d’erreur).
….
int main(int argc, char *argv[]): On obtient
}
alors des programmes auxquels on peut
end adresser des arguments au moment où on lance
le programme.
Entre accolades "{" et "}" on
mettra la succession d'actions à
réaliser.(Bloc)

11
 Structure d'un programme C
#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur :
#define FIN 10 accès avant la compilation
#define MSG "Programme de démonstration\n"
int fonc1(int x);
int fonc2(int x); Déclaration des fonctions

void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définitions des
}
fonctions
int fonc2(int x) {
return (x * x);
}
12
 Indenter = lisibilté #include <Lib1.h>
#include <Lib2.h>
Prenez l'habitude de respecter (au moins au début) les #define X 0;
règles :
int fonc1(int x);
- une accolade est seule sur sa ligne, float fonc2(char a);
- { est alignée sur le caractère de gauche de la ligne
précédente, int main(void)

- } est alignée avec l'accolade ouvrante correspondante, { /*main*/

instruction;
- après { , on commence à écrire deux caractères plus à
droite. instruction;
{
Fonctionnement : instruction;
{
- Taper et sauvegarder le programme,
instruction;
- Compiler le programme,
- Exécuter le programme. }
}
instruction;
} /* fin main*/ 13
 Préprocesseur
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)

14
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{

printf(" ENSAM GI "); ENSAM GI

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */

15
La fonction printf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int printf( const char *format [, arg [, arg]...]);

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

Exemple :
printf("Qu'il est agreable d’utiliser printf "
"en\t C,\nlorsqu'on l'utilise \"proprement\".\n");

Résultat sur la sortie :

Qu'il est agreable d’utiliser printf en C,
lorsqu'on l'utilise "proprement".

Les caractères précédés de \ sont interprétés comme suit :

\\ : caractère \
\n : retour à la ligne
\t : tabulateur.
\" : caractère "
\r : retour chariot
16
Les constantes de type caractère ont une valeur entière dans la table
ASCII(American Standard Code for Information Interchange)
char c1 = 'A',
c2 = '\x41'; /* représentation hexadécimale */
caractères nom symbole code hexa décimal
\n newline LF 10
\t tabulation HT 9
\b backspace BS 8
\r return CR 13
\f form feed FF 12
\\ backslash 5C 92
\' single quote 27 39
\" double quote 22 34

17
La fonction scanf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int scanf(const char *format [argument, ...]);

Description : Lit à partir de stdin (clavier en principe), les différents

arguments en appliquant le format spécifié.
Exemple : scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
!
Format des paramètres passés en lecture et écriture.

"%c" : lecture d'un caractère.

"%d" ou "%i" : entier signé.
"%e" : réel avec un exposant.
"%f" : réel sans exposant.
"%g" : réel avec ou sans exposant suivant les besoins.
"%G" : identique à g sauf un E à la place de e.
"%o" : le nombre est écrit en base 8.
"%s" : chaîne de caractère.
"%u" : entier non signé.
"%x" ou "%X" : entier base 16 avec respect majuscule/minuscule.
18
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Je te souhaite le bon"
L’utilisation de & est indispensable avec
"jour aux TP\nEt je t"
scanf (valeur lue et donc modifiée), pas avec
"e souhaite bon trav"
printf (valeur écrite et donc non modifiée).
"ail\n");
!
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\nAlors ton age 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". */
}
Quel est ton âge ? 18
Alors ton age est de 18 ans!
19
 Variables : déclarations
Syntaxe : Type identificateur1, identificateur2, …,…. ;

Exemple: char c1, c2, c3;

int i, j, var_ent;

Variables : initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{),
zone des déclarations:

void main(void) void main(void)

{ {
est équivalent à
char c; char c = 'A';
int i,j, k;
c = 'A'; int i=50,j, k;
i = 50; j=k=10;
j =10;
= opérateur d’affectation
K=10;

Cette règle s'applique à tous : char, int, float ... 20

 Affichages et saisies
Librairie : stdio.h
Fonction Syntaxe Description

printf printf( const char *format [, arg [, Écriture formatée

arg]...]); : sortie standard

scanf scanf( const char *format [, arg [, Lecture formatée

arg]...]); 7 entrée standard

putchar putchar(int c); Écrire le caractère c

:

getchar getchar(); Lecture d'un caractère

getch(); <conio.h> 7
getch
puts *puts(char *s); Ecriture/Lecture d'une
*gets(char *s); chaîne de caractères,
gets terminée par \n
sprintf sprintf(char *s, char *format, arg ...); Ecrit dans la chaîne
d'adresse s.

sscanf sscanf(char *s, char *format, pointer Lit la chaîne d'adresse s.

...);

21