Structure et éléments du C++

Algorithmique et Programmation
Unisciel/K.Zampieri

1
Liminaire

2
 Le langage C
Historique :
• Développé dans les laboratoires d'AT&T Bell
• Début des années 1970
• Par Dennis Ritchie
Caractéristiques :
• Successeur des langages BCPL et B.
• Objectif initial : remplacer le codage assembleur.
• Succès : langage d'implantation de Unix – Grande
portabilité – Fonctionnalités dans bibliothèques.

3
 Abstraction

Aspect statique Langage Aspect dynamique

données

traitements

Instructions
Variables Programme & expressions
& instances
4
 Abstraction (2)
Instruction : Indique à la machine comment manipuler les
données. En C++, se termine par un point-virgule « ; ».
Variable : Elément informatique manipulé par le programme.
Objet : Elément intégrant "données et traitements".
Classe : Définition des "objets".

5
 Approches procédurale v.s.
orientée objet
Programmation procédurale Programmation objet
Que doit faire le programme ? Sur quoi porte le programme ?

Données Données +
Traitements Données +
traitement Traitements
traitement traitement
Données +
Traitements

6
 Le langage C++
Historique :
• Développé dans les laboratoires d'AT&T Bell
• Début des années 1980
• Par Bjarne Stroustrup

7
 Le langage C++ (2)
Caractéristiques :
• Issu de C.
• Langage orienté objet (OO).
• Compilé (impératif) fortement typé.

C + Typage + Objets
fort (classes)

C++

8
 Le langage C++ (3)
Avantages (+) :
• Un des langages orienté objet le plus utilisé.
• Applications efficaces grâce à la compilation.
• Programmes exempts de bogues syntaxiques et [un peu]
plus robuste grâce au typage fort.
• Compilateur disponible sur de nombreuses plates-formes.
• Documentation abondante grâce à sa large diffusion.

9
 Le langage C++ (4)
Défauts (-) :
• Quelques effets indésirables et comportement peu intuitif
[résulte des inhérences du C].
• Syntaxe parfois lourde et peu naturelle.
• Ne définit ni de techniques de récupération automatique de
mémoire [garbage collector], ni de multiprogrammation, ni
de programmation distribuée.

10
L'environnement de
programmation

11
 Environnement C++ type
Comprend habituellement :
• Un EDI (environnement de développement, IDE en
anglais) de programmes.
• Le langage.
• La bibliothèque standard C++.

12
 Exécution des programmes C++
Phases dans l’ordre chronologique :
• Édition : Création du programme dans l'éditeur.
• Précompilation : Traitement du code par le précompilateur.
• Compilation : Création du code objet.
• Édition des liens : Mise en place des liens entre le code
objet et les bibliothèques ; crée un fichier exécutable.
• Chargement : Placement du programme en mémoire.
• Exécution : de chaque instruction par le processeur.

13
 libc.a libm.a
<iostream> <cmath>

Fichiers bibliothèques
#include <iostream> include
010010010100
int main(int, char*[]) 010010010100
101110101001
{ 101110101001
using namespace std ; Editeur 010101010011
cout << "Bienvenu Compilateur 001010010100
001010010100 de liens 001010101000
l'univers!" << endl ; 001010101000
return 0 ; ….
….
}

prog.cpp prog.obj prog.exe

Editeur de texte Exécution

14
Structure d'un programme C++

15
 Compilation en C++
« Point d'entrée » : une fonction intitulée main.

Compilateur C++

Fichier source Fichier exécutable

commande: gcc prg.cpp –o prg

int main(int, char*[]) 01001001010001011101010
{ 01101010101001010010100
… 10100000101010100000010
return 0 ; 10010011100100000000000
} 0100101011….

16
 Programme « vide » du C++
Syntaxe : int main(int, char*[]) { return 0 ; }
Rôle :
• Déclare la fonction main nécessaire pour produire du code
machine exécutable.
• Définit que cette fonction est vide : son corps (délimité par
les accolades { et }) ne contient que la valeur de retour
"zéro" (signifiant fin normale de programme).

17
 La fonction main
En-tête : int main(int, char*[])
Pour commencer :
• En-tête standard.
• Respectez la casse (m minuscule).
• Chaque programme possède une fonction main.
Lors du démarrage du programme :
• Recherche de la fonction main.
• Exécution de son bloc d'instructions.
• Absence de fonction main : le programme ne démarre pas.

18
 Structure générale d'un
programme C++
#include < des_trucs_utiles >
using namespace std ;
déclaration_d'objets_globaux [à éviter]
déclarations_et_définitions_de_fonctions_utiles
int main(int, char*[])
{
corps_du_programme [si possible assez court]
return 0 ; [fin normale]
}

19
Atomes d'un programme C++

20
 Commentaires en C++
Commenter est un devoir.
Deux styles :
• Commentaires orientés ligne (introduit par le C++) :
// rend le reste de la ligne non-exécutable
• Commentaires orientés bloc (hérité du C) :
/* rend le code entouré non exécutable */

21
 Mots-clés
Rôle : Mots réservés ayant une signification inchangeable et
prédéfinie en C++ (voir liste ci-après).
• Le C++ est sensible à la casse.
• Mots-clés en minuscules.
• En gras (ou en couleurs) dans les environnements IDE.

22
 Mots-clés (2)
C : auto, break, case, char, continue, default, do, double, else,
enum, extern, float, for, goto, if, int, long, return, short, signed,
sizeof, static, struct, switch, typedef, union, unsigned, while
Ansi C : const, register, void, volatile
C++ : asm, bool, catch, class, delete, false, friend, inline, new,
operator, private, protected, public, template, this, throw, true,
try, virtual
Norme C++ : and, and_eq, bitand, bitor, compl, const_cast,
dynamic_cast, explicit, export, mutable, namespace, not,
not_eq, or, or_eq, reinterpret_cast, static_cast, typeid,
typename, using, wchar_t, xor, xor_eq

23
 Identifiant
Syntaxe : N'importe quelle séquence (à l'exception des mots
réservés du langage : if, else, while…) composée de lettres
(A..Z et a..z), de chiffres (0..9) ou du caractère souligné (_)
et débutant par une lettre ou le souligné.
Attention! Les accentués ne sont pas des lettres anglophones.
Conseil : Utilisez des noms aussi explicites que possible.

24
 Types élémentaires
Types de base fondamentaux :
int : les nombres entiers.
double : les nombres réels (approchés).
char : les caractères (alphanumériques).
bool : les valeurs logiques “vrai” (true) et “faux” (false).

25
 Valeurs Littérales
Sont des constantes associées aux types de base du langage.
On distingue les valeurs littérales de :
• Type entier  Littéraux entiers
• Type réel  Littéraux réels
• Type caractère  Littéraux caractères
• Type chaînes de caractères  Littéraux chaînes
• Type booléen  Littéraux booléens : false, true

26
 Littéraux entiers
Notation : suite de chiffres préfixé éventuel d’un signe (+ ou -)
Exemple : 1, -12, …

27
 Littéraux réels
Notation : Suite de chiffres avec point décimal ou écriture en
notation scientifique m e p signifiant m · 10 p (où m est une
suite de chiffres décimaux et p un entier) (e.g. 12.4e-5
12.4 · 10-5  0.000124). Le symbole e correspond à la
puissance de 10
Exemple : 0.0, .12, 12e4, 12.4e-5
Note : Un réel se distingue d'un entier par l'ajout d'un point (.)
à la fin. Pour la lisibilité, préférez .0
[e.g. 5.0 (réel)  5 (entier)].

28
 Littéraux caractères
Notation : un caractère entre quote
Exemple : 'a', '!', …
• Le caractère ' se représente par \'
• Le caractère \ se représente par \\
• Le backslash \ est appelé caractère d'échappement.

29
 Littéraux caractères (2)
Principales constantes caractères :
\a Bip sonore (bell) \\ Barre oblique inversée
\b Retour arrière \' Apostrophe
\f Saut de page \" Guillemet double
\n Saut de ligne \0oo Valeur en format octal
\r Retour chariot (oo nombre octal)
\t Tabulation horizontale \xhh Valeur en format hexa
\v Tabulation verticale (hh nombre hexa)

30
 Littéraux chaînes
Notation : suite de caractères entre guillemets
Exemple : "Qu’est une chaîne? Une phrase entre guillemets"

31
Déclarations et Affectation

32
 Variable
Définition : donnée dont le contenu peut varier au cours de
l'exécution du programme.
En C++, décrite par :
• Son identifiant (ou identificateur) : nom par lequel la
donnée est désignée.
• Son type : définit de quel « genre » est la donnée associée à
la variable ; en particulier, quels traitements (opérations)
elle peut (et ne peut pas) subir.
• Sa valeur.

33
 Déclaration et initialisation de
variables
Dans les langages typés (comme le C++) :
• Déclaration = Création d'une variable.
• Initialisation = Association d'une valeur à la variable créée
[En POO, on parle d'instanciation].
Avant d'être utilisée une variable :
• Doit être déclarée.
• Est à initialiser (de façon interne ou externe).
Note : Le compilateur n'interdit pas l'utilisation d'une variable
non initialisée mais exclut celle de variables non déclarées.

34
 Déclaration et initialisation de
variables (2)
Syntaxe :
T v ; // déclaration
T v = valeur ; // déclaration/initialisation
T v(valeur) ; // autre écriture: déclaration/initialisation
Rôle : Déclare une variable de type T, d'identifiant v (le nom)
et l'initialise à la valeur (littéral ou expression) indiquée.
Conseil : Initialisez toujours vos variables.
Note : Le littéral 0 est une valeur d'initialisation qui peut être
affectée à une variable de n'importe quel type élémentaire.

35
 Variable v.s. constante
Par défaut une variable en C++ est modifiable.
Constante = "variable" auquel on assigne une valeur lors de
sa déclaration et dont la valeur ne peut pas être modifiée
par le programme : toute tentative est rejetée par le
compilateur qui signalera une erreur (ou un avertissement).

36
 Définitions de constantes
Syntaxe :
const T k(valeur) ; // déclaration usuelle
enum { K = valeur } ; // si type discret
Rôle : Définit la constante nommée k de type T et lui affecte
valeur (littéral ou expression).

37
 Affectation simple
Syntaxe : v = valeur ; // algorithmique: v  valeur
Rôle : Affecte valeur (littéral ou expression) à la variable v.
Attention! Les types doivent correspondre (à l'exception de
quelques conversions implicites).

38
 Réutilisation d'une variable
Que se passe-t-il ?
• L'affectation remplace l'ancienne valeur.
• La partie droite est évaluée avant l'affectation.

39
Entrées/sorties

40
 Interagir avec l'extérieur:
entrées/sorties (E/S)
Via les instructions d'E/S.
Buts des E/S :
• Prendre en compte des données issues de l'extérieur (e.g.
informations saisies au clavier ou lues dans des fichiers).
• Afficher des résultats, des informations à l'écran.
• Sauvegarder des résultats pour d'éventuelles réutilisations.

41
 E/S clavier/écran
Interactions les plus simples (et « naturelles ») :
• cin : nom de la variable associée à l’« entrée standard ».
• cout : nom de la variable associée à la « sortie standard ».
cin >>

Mémoire
du PC

cout <<
42
 E/S clavier/écran (2)
Pour les utiliser : #include <iostream>

Prononciation :
• cin : c-in (canal input)
• cout : c-out (canal output)

43
 Affichage à l'écran
Syntaxe : cout << expr1 << expr2 << … << exprN ;
Rôle : Affiche sur la sortie standard (l'écran) les valeurs des
expressions expri .
• Les chaînes de caractères sont entre les guillemets (").
• Les caractères simples sont entre les apostrophes (').
• Par défaut les valeurs affichées ne sont pas séparées par
des espaces. Ajoutez le(s) délimiteur(s) si nécessaire.
• Le manipulateur endl représente le retour de ligne : il
permet de passer à la ligne suivante et ordonne le vidage
du tampon d'affichage.
44
 Saisie au clavier
Syntaxe : cin >> var1 >> var2 >> … >> varN ;
Rôle : Lit depuis l'entrée standard (le clavier) une liste de
valeurs vali et les stockent dans les variables vari (qui
doivent exister). Saute tous les blancs (espace, tabulation,
fin de ligne).
• Lorsque plusieurs valeurs sont lues à la suite, le caractère
séparateur de ces valeurs est le retour à la ligne ou l'espace.
• Attention! On ne peut pas lire en une fois une ligne entière
contenant des blancs avec l'opérateur « >> ». [cf. cours
Chaîne de caractères]

45
Opérateurs et expressions
algébriques

46
 Opérateur
Définition : Symbole permettant de manipuler deux valeurs.
Sa définition est associée au type des valeurs sur lequel il
peut opérer.

Exemples : Algébriques (+, -, *, /, …) définis pour les types

numériques (entiers et réels), logiques (!, &&, ||) pour les
types booléens, de comparaison (<, <=, >, >=, ==, !) pour
les types numériques et les caractères, etc.

47
 Expression
Séquence (« bien formée » (BF) au sens de la syntaxe)
combinant (via des parenthèses) des opérateurs et des
opérandes (valeurs littérales, variables ou expressions).

Exemples :
• (2*(13-j)/(1+4)) : expression numérique BF
• (3+(5*(-2) : non BF [parenthésage incorrect]
• 3 (5) * )-2( : non BF [opérateur et parenthésage incorrect]

48
 Évaluation d'une expression
Conduit à sa valeur littérale correspondant au résultat de
l'expression. [Résulte de ce que les opérateurs ont une
syntaxe et une définition opératoire.]

Exemple :
• eval[ (2*(13-3)/(1+4)) ]  valeur littérale de type entier 4

49
 Opérateurs algébriques
Tous associatifs à gauche.
Dans leur ordre de priorité d'évaluation :
Opérateur Opération
* Multiplication
/ Division
% Modulo (reste de la division entière)
+ Addition
- Soustraction
OUPS ! Pas d'opérateur puissance en C++

50
Priorité entre opérateurs algébriques
Règle d'évaluation :
• En l'absence de parenthésage, les multiplicatifs (*, /, %)
puis les additifs (+, -).
• Règle d'associativité en cas d'ambiguïté entre opérateurs du
même ordre de priorité.
Exemple :
a * b % c  (a * b) % c
a % b * c  (a % b) * c
a + b * c % d  a + ((b * c) % d)
Conseil : Parenthésez (ne serait-ce que pour la lisibilité !).
Exemple : Ecrivez (a*b)%c plutôt que a*b%c.
51
 Priorité entre opérateurs
algébriques : exemple
(1) (2) (1) (1) (2) (0)

a * b - c / d % e + f D'abord la

( a * b ) - ( c / d % e ) + ( f ) « gestion
des
(( a * b ) - ( c / d % e )) + ( f ) priorités »
(( a * b ) - (( c / d ) % e )) + ( f ) suivi des
2 3 1 « évaluations »
4
5
6

52
 Opérateurs algébriques pour
l'affectation
Exemple d'utilisation d'expressions pour l'affectation :
• z = (x + 3) % y + 10 ;
• z = (x = 3 * y) / 2 ;
Notations abrégées pour des affectations particulières :

Affectation Notation abrégée

x=x+y x += y
idem pour {-, *, /, %}
x = x + 1 // x discret ++x // préfixe
idem pour {-} (ou x++) // postfixe

53
 Que vaut a / b en C++ ?
ATTENTION PIèGE !
Si a ET b entiers Si a OU b réels
 Division euclidienne  Division (réelle)
Relation : Exemple : a = 17, b = 3
a = (a / b) * b + (a % b)  17.0/3 = 17/3.0  5.6666667
= q * b + r (avec 0|r|<|b|)
Exemple : a = 17, b = 3
 q = 17/3 = 5, r = 17%3 = 2
 17 = 5 * 3 + 2

54
 Variables, types: Mémo
Une donnée est stockée dans une variable caractérisée par :
(i) son type et son identifiant (définis lors de la déclaration)
(ii) sa valeur, définie la première fois lors de l'initialisation
puis éventuellement modifiée par la suite.
Syntaxe : T v ; T v(val) ;
Types élémentaires : int, double, char, bool
Affectation : v = expr
Saisie : cin >> v >> …
Affichage : cout << expr << …

55
 Opérateurs algébriques : Mémo
Opérateurs algébriques :
* (multiplication)
/ (division) Opérateurs multiplicatifs
% (modulo)
+ (addition) Opérateurs additifs
- (soustraction)
++ (incrémentation, unaire)
Opérateurs de crémentation
-- (décrémentation, unaire)

56