S1 - LSIS

Langage C
Rémy Bulot
[email protected]
Progression :
1. 
2. 
3. 
4. 
5. 
6. 
Notion d'algorithme et de programme
Premiers pas en C
Type entier, réel, constantes et variables
Les entrées-sorties simplifiées
Expressions arithmétiques et logiques
Syntaxe des instructions
7.  Les entrées-sorties
8.  Quelques compléments commodes
9.  Variables indexées (tableaux)
10.  Adresse et pointeur
11.  Les Fonctions
12.  Les objets structurés
13.  Les fichiers
14.  Piles, files, listes chaînées
I.
Notion d’algorithme
Un parallèle culinaire
Une recette de cuisine
Algorithme
Ingrédients
Données (entrées)
Recette
Algorithme
Plat
Résultat (sorties)
a) Définition
•  Suite finie et non ambiguë d’instructions
•  dans un langage pseudo-naturel simple
•  permettant de décrire une méthode pour répondre à un problème
•  en s’affranchissant des aspects matériels de mise en œuvre (type de machine, langage
de programmation utilisé, …)
L’étape suivante sera de traduire cet algorithme dans un langage de programmation
« compréhensible » et exécutable par une machine
données
problème
algorithme
programme
solutions
b) Analyse préliminaire et développement d’un algorithme
•  Poser clairement le problème
o  Spécification des données à partir de l'énoncé du problème, d'hypothèses, ou de
source d'informations externes, ...
o  Spécification des buts à atteindre à partir des résultats attendus, des suites
d'opérations à effectuer, ...
o  S'assurer que le problème puisse être traité (il y a des problèmes indécidable !)
o  Simplifier éventuellement le problème (ex : calcul des décimales de π ...)
•  Définir l'algorithme
o  Tout objet manipulé doit être clairement défini (nature et rôle) avant son usage.
o  Définir une suite d’instructions simples :
o  non ambiguë
o  exécutable en un nombre fini d’opérations
o  dans un temps limité
o  et qui doit produire un résultat
a) Définir un premier algorithme très général
•  ensemble d’actions de haut niveau
•  à réaliser de manière séquentielle
Recette des crêpes au nutella :
I.  Définir les ingrédients (350g de farine, ½ litre de lait, 3 œufs)
II.  Faire la pâte à crêpe
III.  Cuire une crêpe dans une poêle
IV.  Étaler du nutella sur la crêpe
b) Raffinement des tâches
Chaque action (ou tâche) peut-être vue comme un sous problème
•  avec ses données et son résultat spécifiques
•  et qui peut être résolu isolément
â  raffinement de chaque tâche
On enchaîne des raffinements successifs :
â  Conception structurée
Raffinement successifs :
Recette des crêpes au nutella :
I. 
Définir les ingrédients
II. 
Faire une pâte à crêpe
1. 
2. 
3. 
4. 
5. 
III. 
IV. 
Mettre 350g de farine dans un bol
Ajouter ½ litre de lait
Mélanger
Ajouter 3 œufs
Mélanger
Cuire une crêpe dans une poêle
Étaler du nutella sur la crêpe
Action Mélanger : répétition d’une action élémentaire :
Tant que le mélange n’est pas homogène,
-  tourner la pâte avec une cuillère
3. Eléments de base pour écrire un algorithme
Une recette de cuisine
Un algorithme
•  ingrédients (farine, beurre, …)
données
•  récipients (plat, bol, …)
•  outils (couteaux, mixeur…)
variables
opérateurs
•  instructions simples (verser, …)
affectation, …
•  instructions conditionnelles
si-alors-sinon
•  instructions répétitives
tant-que
"Outils" de base pour écrire un algorithme
a)  définition d'une variable
b)  lecture/écriture
c)  expressions arithmétiques et logiques
d)  affectation
e)  instruction conditionnelle
f)  répétition d’une action
a) Définir une variable
ð  nommer au début les variables utilisées (contenants)
ð  en précisant la nature du contenu (entier, réel, caractère…)
ex : soient a, b, c trois réels
b) Instruction de lecture/écriture
ð  pour représenter les échanges homme-machine
•  lire (variable)
homme -> machine
•  écrire(variable)
homme <- machine
c) Expressions
ð 
Expression arithmétique (dans N, Z, R…)
ex : b2-4ac
ð 
Expression logique (résultat VRAI ou FAUX)
avec les opérateurs ET, OU, NON, = , ≠ , < , ≤
ex : 0 < b2-4ac
ET
vrai
faux
OU
vrai
faux
vrai
vrai
faux
vrai
vrai
vrai
Faux
faux
faux
faux
vrai
faux
d) Affectation :
• 
Une variable ne peut contenir qu’une seule information
variable <- expression
• 
l’affectation qui initialise
x <- 1
s <- x+1
• 
l’affectation qui modifie
s <- s+x
Remarques :
• 
lire est une forme d’affectation
• 
variable à droite de <- : désigne le contenu (la valeur)
• 
variable à gauche de <- : désigne le contenant (zone mémoire)
s <- s+x
e) Instruction alternative
•  Action liée à une condition
si (condition)
action1
sinon
action2
fin-si
suite de l’algorithme
oui
condition
non
action1
action2
Remarques :
•  les actions sont des suites d’instructions élémentaires
•  délimitées par si, sinon et fin-si
•  sinon action2 est facultatif
•  présentation : il faut indenter les instructions de chaque action
f) Instruction répétitive
•  Action répétée sous condition
tant-que (condition)
action
fin tant-que
suite de l’algorithme
action
oui
condition
non
5. Quelques exemples :
•  l’algorithme pour la résolution de l’équation du 2ème degré
•  l’algorithme mystérieux
soient a, b, r entiers;
lire(a) ;
lire(b) ;
r <- 0 ;
tant-que (b ≠ 0)
si (b est pair)
b <- b/2 ;
a <- 2*a ;
sinon
b <- b-1 ;
r <- r+a ;
fin-si
fin tant-que
ecrire(r) ;
Résumé chap. I
• 
Un algorithme est une recette obtenu par affinements successifs
• 
Il manipule des contenants (variables) et des contenus (valeurs)
• 
Il s'affranchit des contraintes spécifiques aux langages
• 
Les outils disponibles :
o  définir les variables : soient a un réel, i un entier, c un caractère
o  les opérateurs arithmétiques et logiques (≠ , = , < , ≤ , et , ou , non)
o  initialiser une variable : a <- 2*3.14
i <- 0
c <- 'Z'
o  modifier une variable : a <- a*a
i <- i+1
c <- c-'A'+'a'
o  si condition alors action fin si
o  tant que condition faire action fin tant que
• 
Recommandations :
o  ne jamais utiliser une variable non initialisée (contenu "aléatoire")
o  simuler les départs de boucle et les fins de boucle en étudiant le contenus des
variables pour valider vos algorithmes
o  connaître les algo. de bases : compter et accumuler (moyenne,...), calculer des
suites (xn, x!, ...), chercher une valeur particulière dans une suite (min, ...), ...
II.
Premiers pas en C
Introduction
Langage de programmation :
•  syntaxe non ambigüe qui permet de retranscrire un algorithme en une suite
d'instructions qui seront ensuite converties en langage machine
•  prend en compte les spécificités techniques de la machine (contrairement à un
algorithme)
•  Cette suite d'instructions est désignée "code source"
Compilateur :
•  spécifique au langage
•  programme qui permet de traduire le texte du programme (code source) en
instructions machines de bas niveau (code exécutable)
•  prend en compte les spécificités techniques de la machine
données
problème
algo.
Code source
Compilation
code exécut.
solutions
Le C a été mis au point par D.Ritchie et B.W.Kernighan
•  Au début des années 70
•  Pour écrire un système d'exploitation portable : UNIX
•  Le succès d'UNIX a entraîné celui de C :
•  un des langages le plus utilisé (gestion des réseaux, …).
La première définition de ce langage a été donnée dans leur livre
« The C programming language ».
Ce langage a été normalisé en 1989 : C-ANSI
(American National Standards Institute)
Quelques caractéristiques du langage :
•  adapté aux programmes de taille moyenne
•  programmation de bas niveau (proche assembleur)
•  comme de haut niveau (programmation structurée)
•  indépendant de la machine (portabilité)
•  C original et C-ANSI (1989) plus fiable au niveau syntaxique
Ce cours : un sous-ensemble du C-ANSI
Premières remarques sur la constitution d’un programme C :
•  Programme C :
fichier texte
•  Commentaires :
/* coucou */
1. Développement d’un programme
1 : L’algorithme : « recette » décrite en pseudo-français
2 : Code source : transcription de l’algorithme dans le langage
fichier construit sous un éditeur de texte
3 : Compilation : traduction du code source en code machine exécutable
4 : Edition de lien : (link) compléter le code avec des fonctions prédéfinies
déjà compilées (sin , sqrt, …)
â  Fichier exécutable : résultat de cette séquence d’opérations
Développer un programme :
•  réaliser les 4 étapes
•  tester l'exécution avec différents jeux de données
•  recommencer la séquence jusqu'à obtention d'un fonctionnement satisfaisant
2. Code source
Un fichier source est une succession d'un nbre quelconque
d'éléments indépendants :
•  directives pour le préprocesseur (lignes qui débutent par # )
•  construction de types
•  déclaration de variables et de fcts externes
•  définition de variables (réservation d'espace mémoire)
•  définition de fcts dont la fct principale main( )
!
!
!
3. Compiler/executer
Fichier source salut.c!
/* Auteur : Melanie Zettofret!
Objectif : afficher coucou ! */!
!
#include <stdio.h>!
!
void main(void)!
{ !!
printf("coucou !\n");!
}!
!
!
Dans une console UNIX :
Compiler avec la commande
gcc salut.c –o salut
lancer l’exécution du code en tapant
./salut
!
III.
Constantes, types et variables
1. 
2. 
3. 
4. 
Constantes
Identifiateurs
Variables
Affectation
1.  Les constantes
Ce sont les valeurs définies explicitement.
On distingue :
- les caractères alphanumérique-étendus
‘a‘ ‘A‘ ‘1‘ ‘ ‘ ‘@‘ ‘\n‘
- les entiers
0
-1
32767
3.14
0.314e1
- les réels
0.
ATTENTION : 1 est différent de ‘1‘
0.314E1
2. Identificateur
•  Pourquoi faire ?
donner des noms aux variables et aux actions
•  31 caractères max, majuscule ≠ minuscule
identificateur : lettre[lettresOuChiffresOu_ ]
•  Exemple : x
x1 delta
Delta
Bond_007
•  Mots réservés du langage (voir fiche résumé) :
o  une trentaine
o  tous en minuscule
!
3. Variable
•  un emplacement mémoire (1, 2, 4 octets ou plus)
•  on en crée (presque) autant qu’on veut
•  en donnant des noms qui suggèrent bien leurs rôles
compteur, somme, valeurMin, ...
•  le contenu peut changer dans le temps
•  contient toujours quelque chose !!!
Une variable sera toujours définie avant utilisation par :
•  un type (sa nature qui détermine sa taille)
•  et un identificateur (son nom)!
3.1 Type d’une variable
•  convention de codage de l'information
•  dans un emplacement de taille préfixée
7 types de base en C :
ü  char : petit entier codé sur 1 octet (entre –128 et 127)
ü  short : entier de taille moyenne sur 2 octets (de –32768 à 32767)
ü  long : grand entier sur 8 octets (jusqu’à 19 chiffres)
ü  int : entier dont la taille est liée au processeur (mot machine)
ü  float : réel avec 7 chiffres significatifs
ü  double : réel de grande précision
ü  long double : réel de très grande précision
Le qualificatif unsigned : redéfinit l’intervalle de validité à partir de 0
Un unsigned short est dans [0, 65535]
Un unsigned char est dans [0, 255]
3.2 Définition d'une variable :
Objectifs :
•  réserver un emplacement mémoire
•  qui soit adapté au codage de l’information
•  associer un nom (identificateur) à cet emplacement
Syntaxe pour la définition de variable :
-> type variableInit [ , variableInit ] ;
où variableInit :
-> identificateur
-> identificateur = expression constante
Exemple :
!float x;!
!long i, j=1, k ;!
!char c1='1', c2 = 2 ;!
!
Exemples d’erreur :!
!int i=0, j=i+1 ;!
!char a=300 ;!
!
!
Remarques :
•  Le C ne fait pas de différence entre les petits entiers et les caractères
qui sont déclarés indifféremment comme des char
binaire
01000001
char c ;
65
petit entier
codé en binaire
‘A‘
Caractère
représenté par son
code ASCII (65)
•  Le code ASCII des lettres et des chiffres respecte l’ordre partiel
intuitif des caractères alphanumériques
‘a’ (97), ‘b’ (98), …
‘A’ (65), ‘B’ (66), …
‘0’ (48), ‘1’ (49), ‘2’ (50), …
4. Affectation d'une variable :
Syntaxe simplifiée de l'instruction d'affectation :
variable = expression ;
Exemple :
/* définition d'une variable */
short cpt;
/* affectation d'une variable */
cpt = 0 ;
cpt = cpt+1 ;
Résumé chap. II et III
• 
Comprendre les types et leur codage (nbre d'octets occupés, capacité de codage)
o  float a, b ; double x ; long double distTerreLune ;
o  char i ; short compteur ; int moyenne ; long numTel ;
o  char carCourant ;
o  unsigned long distance ; unsigned char pixRouge, pixVert, pixBleu ;
•  Affectation d'une variable :
•  compteur = 0 ;
•  compteur = compteur+1 ;
• 
Remarques et Recommandations :
o  Les char représentent à la fois les caractères et les petits entiers (le code ASCII
qui représente un caractère est un petit entier)
o  Ils ne se distinguent que par les opérations de lecture/écriture
o  Les calculs doivent respecter la capacité de codage de chaque type (risque de
"débordement")
o  Utiliser des noms de variables mnémoniques