Cours de C++, en français, 2002 - Cours 1.2

Cours C++ (2002)
semaine 1
jour 2

Cours semaine 1, jour 2 Cours C++ (2002) 2
Plan du jour
 Le langage C : rappels sur les structures et
les données
 Les modifications aux structures du langage
C apportées par C++

Remarque préalable
 Le langage C permet d’atteindre très
rapidement un niveau de « saleté »
important : les programmes sont rapidement
illisibles et, par conséquent, bogués…
 Il est nécessaire de définir un ensemble de
règles de codage (coding style) pour éviter
les incompréhensions et améliorer la
lisibilité

Coding style
 Discutez entre vous de vos standards et de
vos habitudes de rédaction de programmes
 Définissez une norme, suivie par tous
 Même si cela prend du temps, commentez
vos programmes
 La rédaction de programmes en C ou C++
n’est pas un concours de technicité et
d’illisibilité : certains s’y sont essayés…

Illisibilité
 C est un langage parfait pour l’illisibilité
 Des concours annuels sont même organisés
 IOCCC : International Obfuscated C Code
Contest
 http://www.ioccc.org
 Un grand nom du langage C, Ken
Thompson, reconnaît qu’il n’aimerait pas
travailler avec des gens comme lui 

Illisibilité – Exemple 1
#include <stdio.h>
#include <math.h>
double l;main(_,o,O){return putchar((_--+22&&_+44&&main(_,-43,_),_&&o)?(main(-
43,++o,O),((l=(o+21)/sqrt(3-O*22-O*O),l*l<4&&(fabs(((time(0)-
607728)%2551443)/405859.-4.7+acos(l/2))<1.57))[" #"])):10);}

Illisibilité – Exemple 2
int m = 754974721, N, t[1 << 22], a, *p, i, e = 1 << 22, j, s, b, c, U;
f (d)
{
for (s = 1 << 23; s; s /= 2, d = d * 1LL * d % m)
if (s < N)
for (p = t; p < t + N; p += s)
for (i = s, c = 1; i; i--)
b = *p + p[s], p[s] = (m + *p - p[s]) *
1LL * c % m, *p++ = b % m, c = c * 1LL * d % m;
for (j = 0; i < N - 1;)
{
for (s = N / 2; !((j ^= s) & s); s /= 2);
if (++i < j)
a = t[i], t[i] = t[j], t[j] = a;
}
}

Illisibilité – Exemple 2, suite
main (){
*t = 2;
U = N = 1;
while (e /= 2)
{
N *= 2;
U = U * 1LL * (m + 1) / 2 % m;
f (362);
for (p = t; p < t + N;)
*p++ = (*p * 1LL ** p % m) * U % m;
f (415027540);
for (a = 0, p = t; p < t + N;)
a += (6972593 & e ? 2 : 1) ** p, *p++ = a % 10, a /= 10;
}
while (!*--p);
t[0]--;
while (p >= t)
printf ("%d", *p--);
}

Illisibilité - conclusions
 Inutile de suivre un cours pour écrire
comme ça… Quoique
 Besoin de cours intensifs, réguliers et
répétés pour ceux qui seront chargés de la
maintenance !

Les 10 commandements
 Une série de commandements a été faite
permettant à chaque programmeur de
prendre conscience de certains problèmes
 Mieux vaut connaître ces commandements
avant de se rendre compte de leur utilité,
une fois que le mal est fait
 Ils ont originellement été écrits en vieil
anglais, comme dans certaines bibles des
années 70…

Commandement 1
 "Thou shalt run lint frequently and study its
pronouncements with care, for verily its
perception and judgement oft exceed thine."
 lint est un outil d’analyse du code qui permet de
trouver des erreurs qui apparaîtront très
probablement à l’exécution
 Les compilateurs modernes effectuent des tâches
similaires
 Rational Purify permet d’excellentes vérifications

Commandement 2
 "Thou shalt not follow the NULL pointer,
for chaos and madness await thee at its
end."
 C et C++ utilisent abondamment les
pointeurs
 Un pointeur NULL peut être la cause de
plantages : il faut effectuer des vérifications
aussi souvent que possibles sur les variables
peu sûres

Commandement 3
 "Thou shalt cast all function arguments to
the expected type if they are not of that type
already, even when thou art convinced that
this is unnecessary, lest they take cruel
vengeance upon thee when thou least expect
it."
 C est fortement typé mais permet quelques
libertés : elles peuvent coûter chères…

Commandement 4
 "If thy header files fail to declare the return
types of thy library functions, thou shalt
declare them thyself with the most
meticulous care, lest grievous harm befall
thy program."
 C permet d’effectuer de la compilation
séparée et C++ possède des classes (idem) :
les signatures des fonctions doivent être
parfaitement accessibles et connues

Commandement 5
 "Thou shalt check the array bounds of all strings
(indeed, all arrays), for surely where thou typest
"foo'' someone someday shall type
"supercalifragilisticexpialidocious''."
 Autre facette des pointeurs, avec le problème des
NULL : même si vous écrivez un programme et
codez certaines variables en dur, des modifications
ultérieures pourraient être la cause de graves
problèmes d’exécution

Commandement 6
 "If a function be advertised to return an
error code in the event of difficulties, thou
shalt check for that code, yea, even though
the checks triple the size of thy code and
produce aches in thy typing fingers, for if
thou thinkest "it cannot happen to me'', the
gods shall surely punish thee for thy
arrogance."
 Tester les codes d’erreur retournés

Commandement 7
 "Thou shalt study thy libraries and strive not
to reinvent them without cause, that thy
code may be short and readable and thy
days pleasant and productive."
 Est vrai, reste et restera vrai pour tous les
langages offrant des librairies : C, C++,
Java, Ada, etc.

Commandement 8
 "Thou shalt make thy program's purpose
and structure clear to thy fellow man by
using the One True Brace Style, even if thou
likest it not, for thy creativity is better used
in solving problems than in creating
beautiful new impediments to
understanding."
 La lisibilité réexpliquée

Commandement 9
 "Thy external identifiers shall be unique in the
first six characters, though this harsh discipline be
irksome and the years of its necessity stretch
before thee seemingly without end, lest thou tear
thy hair out and go mad on that fateful day when
thou desirest to make thy program run on an old
system."
 Limitation des premiers compilateurs, à prendre
encore en compte dans le monde de l’embarqué où
C a été utilisé en premier

Commandement 10
 "Thou shalt foreswear, renounce, and abjure
the vile heresy which claimeth that "All the
world's a VAX'', and have no commerce
with the benighted heathens who cling to
this barbarous belief, that the days of thy
program may be long even though the days
of thy current machine be short."
 Le monde change parfois. Remplacer VAX
par WinTel

Les 10 commandements, fin
 Ces règles finissent toujours par
réapparaître et par s’imposer d’elles mêmes
 Autant les prendre en compte immédiatement
 Ces sont des règles applicables lors de la
phase de codage qui ne remplacent en aucun
cas les besoins d’une gestion de projet

C et C++
 C est un langage ancien, mellant des
capacités de programmation à bas niveau
(juste au dessus de l’assembleur) à des
capacités de programmation à haut niveau, à
la manière de Pascal
 C est un langage procédural
 C est le successeur du langage B auquel il
ajoute la notion de type
 B : il ne s’agit pas de la méthode formelle !

C et C++ (2)
 C et UNIX ont la même origine : les
laboratoires d’ATT Bell
 Le premier programme C est UNIX
 UNIX devait au départ servir dans les
commutateurs téléphoniques
 Ceci explique en partie les différents niveaux de
programmation offerts par C

C et C++ (3)
 C++ date du début des années 80 : ajout de
la notion de classe
 1990 : ajout des notions de templates et
d’exceptions
 1993 : ajout de la notion de namespace
 Processus de normalisation entre 1995 et
1997
 Normalisation ANSI/ISO en 1998

L’ancêtre C
 ANSI C est un sous ensemble de C++ : tous
les programmes ANSI C peuvent être
compilés en C++
 C++ peut être utilisé sans la moindre notion
d’objet. Mais ce n’est plus du C++, c’est du
C…
 Toutes les règles syntaxiques de C restent
donc valables en C++

ANSI C – Types de bases
 Booléen : pas de type véritable, utilise les
entiers (int)
 0 représente FALSE, les autres entiers
représentent TRUE
 Caractère : char ou wchar_t
 Un caractère se différentie par une simple
quote, 'a'
 Le rien a un type…void

Types de bases (2)
 En C, les chaînes de caractères (string) sont
en fait des tableaux de caractères
 Se différencient par des doubles quotes, "ansi"
 Les entiers sont sous-divisés en trois
groupes
 short int, int et long int, pouvant représenter
des chiffres de plus en plus importants
 Qualificatifs supplémentaires : signed et
unsigned, pour entiers signés ou non

Types de bases (3)
 Les chiffres réels peuvent s’utiliser avec
deux types : float et double
 Comme pour les entiers avec short, int et long,
float et double sont capables de représenter des
nombres réels de taille différente
 Qualificatifs des nombres
 F ou f pour float
 L ou l pour long ou double
 U ou u pour unsigned

Types de bases (4)
 Problème de représentativité/expressivité
 Pas de normalisation sur les anciens
compilateurs
 int et float utilise un mot
 En fonction des plateformes : 8, 16 ou 32 bits
 Demain : 64 bits
 short utilise un demi mot
 long et double utilisent deux mots
 Problèmes lors du portage d’un programme

Types de bases (5)
 Sur une plate-forme 32 bits
 int permet de représenter des chiffres de
 -2^31 à (2^31)-1 soit
 -2.147.483.648 à 2.147.483.647
 short permet de représenter des chiffres de
 -2^15 à (2^15)-1
 long
 -2^63 à (2^63)-1 ; Pas chez Microsoft : long = int !
 unsigned int
 0 à (2^32)-1

Types de bases (6)
 Mais encore, sur plate-forme 32 bit
 Float utilise 1 mot, c’est à dire 32 bits
 +/-1,2 e-38 à +/-3,4 e38
 double utilise 2 mots, c’est à dire 64 bits
 +/-2,2 e-308 à +/-1,8 e308
 Remarque (bis repetita) : En C, la capacité
des types a TOUJOURS été dépendante de
la taille des mots du processeur
 Intel Itanium IA64 : déjà disponible en test

Variables
 Possibilité de définir des constantes
 const double PI = 3.1415
 const char SP = ' '
 C est un langage orienté ligne
 Toutes les lignes d’un programme doivent être
délimitées
 Le symbole de terminaison est ';'
 Une ligne de programme peut être répartie sur
plusieurs lignes physiques

Variables (2)
 Existence de tableaux dans les différents
types de base
 Attention, les strings sont déjà des tableaux…
 int a[ 20 ] = tableau de 20 entiers
 En C, pour un tableau de dimension N, on
utilise les indices de 0 à N-1
 Attention lors des itérations !
 Attention lors du développement de
programmes à partir d’algorithmes en pseudo
code ou en Pascal, surtout scientifiques

Variables (3)
 Possibilité de définir des tableaux à
plusieurs dimensions
 int a[ 2 ][ 3 ]
 Possibilité d’initialiser les tableaux
 int a[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } }
 float fArray[ 5 ] = { 1.0, 2.0, 3.0, 4.0, 5.0 }
 float fArray[ 5 ] = { 1.0 }
 Idem que float fArray[5] = { 1.0, 1.0, 1.0, 1.0, 1.0 }

Variables (4)
 Initialisation des chaînes de caractères
 char chaineA[] = { 'i', 'n', 'i', 't', 0 }
 char chaineA[] = "init"
 Il existe des caractères spéciaux
 0, le caractère null (fin de chaînes)
 n, pour marquer une nouvelle ligne
 Standard UNIX ! Devient br sur Windows
 t, pour marquer une tabulation
 , pour récupérer le caractère

Variables (5)
 Possibilité de définir des types
supplémentaires, utilisant les types de base
 typedef int Length
 Il devient possible d’effectuer une déclaration de
variable telle que
 Length l = 1;
 Équivalente à int l = 1;

Variables (6)
 Possibilité d’utiliser une notion ensembliste
en créant des listes de valeurs : énumération
 enum Etat { on, off, err }
 Déclaration de l’énumération
 Les chaînes de caractères seront en fait des entiers
numérotés à partir de 0
 S’utilise avantageusement dans les switch (+ loin)
 enum Etat e.
 Variable e du type Etat
 Pourra contenir une valeur possible de la définition

Variables (7)
 Possibilité de créer des structures de
données plus complexes en utilisant les
types de base
 typedef struct {
int condition;
float press, temp; } Container
 struct permet de créer une structure de zone
mémoire avec différents champs, à la manière
d’un enregistrement dans un fichier plat
structuré ou une base de données

Variables (8)
 Les structures créent des types (typedef)
 Container ctn
 Les champs d’une structure sont accessibles
avec un adressage pointé
 ctn.condition = 5;
ctn.press = 1013.25;
ctn.temp = 10.0;

Variables (9)
 Différentes définitions
 struct Container1 { … }
 typedef struct { … } Container2
 Et différentes utilisations
 struct Container1 c1, c2;
 Container2 c3, c4;
 Le typedef crée un type et simplifie la
notation

Variables (10)
 Il est possible d’unir des types différents
union test { char a ; int i; double d; }
 Dans un programme, l’utilisation de l’union
test permet de stocker soit a, soit i, soit d !
 Cela marche car la zone mémoire est
réservée en fonction du type le plus
gourmand
 Cela permet d’économiser de la mémoire

Gestion des variables
 La création de variables avec les types de
base s’accompagne d’une réservation
d’espace mémoire
 Aucun espace mémoire n’est réservé a
priori pour une structure : il faut effectuer
l’opération d’allocation mémoire
 malloc( sizeof( Container ) )
 malloc = memory allocation
 sizeof = calcul de la taille mémoire nécessaire

Gestion de la mémoire
 À la différence d’autres langages de
programmation, C gère deux types de
mémoire
 Une pile (stack) : on y empile et dépile les
variables lors d’appels et de retours de
fonctions
 Un tas (heap) : on y réserve des zones de
mémoire grâce à malloc

programme
Gestion de la mémoire (2)
pile tas

Pointeurs
 La mémoire allouée dans le tas est gérée au
travers de pointeurs, un type de base
fondamental en C !
 Container *ctn;
 *ctn est de type structuré Container et donc
 ctn est un pointeur sur une zone mémoire contenant
une structure ctn
 ctn = malloc( sizeof( Container ) );
 malloc renvoie un pointeur sur la zone mémoire
dont la taille est égale à celle d’une structure
Container

Pointeurs (2)
 L’adressage pointé existe encore :
 En version normale :
 (*ctn).press = 1000.0;
 Le point s’applique sur un type de base ou une
structure, donc *ctn
 Les parenthèses sont nécessaires pour des problèmes
de précédence d’opérateurs
 En version flèchée
 ctn->press = 1020.0;
 La flèche s’applique sur les pointeurs, donc ctn

Pointeurs (3)
 L’opérateur malloc permet de gérer
directement la mémoire disponible dans le
tas associé au programme
 C offre ainsi une certaine puissance vis-à-vis du
système d’exploitation
 C offre un chausse-trappe !
 De nombreux programmes C tournent lentement ou
plantent car la mémoire n’est pas désallouée après
utilisation

Pointeurs (4)
 Libération de la mémoire
 free( ctn );
 Désalloue la mémoire précédemment réservée
et associée à ctn
 Il serait bon d’avoir une méthode qui libère
automatiquement la mémoire après
utilisation
 Cela n’existe pas en C

Pointeurs (5)
 Les pointeurs sont puissants
 int i;
int *a;
a = &i;
*a = 3;
 La valeur 0 est utilisée comme pointeur
NULL
 Attention à ne jamais la suivre !

Pointeurs (6)
 Les pointeurs sont durs à suivre
 int& a;
 int* b;

Pointeurs (7)
 Les pointeurs sont très puissants !
 Possibilité de définir des pointeurs sur des
tableaux à plusieurs dimensions pour pouvoir
leur donner leur taille exacte en cours
d’exécution
 int t[128][256] : grosse préréservation
 int **t : le tableau à deux dimensions existe mais est
vide
 Effectuer ensuite une série de malloc : un premier
pour les 128 lignes puis 128 itérations pour les 256
colonnes

Pointeurs (8)
 Les pointeurs permettent bien des choses :
 Un pointeur représente un chemin vers une
variable / valeur
 Une fonction renvoie une valeur
 Il est possible de définir un pointeur vers une
fonction et donc
 Il est possible de définir des tableaux de
fonctions
 Il est aussi possible de définir des pointeurs sur
des indéfinis avec void *

Opérations arithmétiques
 Addition : +
 Soustraction : -
 Multiplication : *
 Division entière ou réelle : /
 Modulo : %
 Pas de notation pour le calcul des exposants
 Incrémentation de 1 : ++
 Décrémentation de 1 : --

Opérations logiques
 ET logique : &&
 OU logique : ||
 NON logique : !
 Test d’égalité : ==
 Test d’inégalité : !=
 Comparaisons arithmétiques : inférieur <,
inférieur ou égal <=, supérieur >, supérieur
ou égal >=

Opérations binaires
 ET sur bit : &
 OU sur bit : |
 NON sur bit : ~
 OU EXCLUSIF sur bit : ^
 Décalage de bits vers la droite : >>
 Décalage de bits vers la gauche : <<

Affectations
 Affectation : =
 Opérations spéciales
 i += a; équivalent à i = i + a;
 i -= a; équivalent à i = i - a;
 i *= a; équivalent à i = i * a;
 i /= a; équivalent à i = i / a;

Point d’entrée
 Un programme est une suite de fonctions
(qui renvoient des valeurs) et de procédures
(qui ne renvoient rien)
 Cependant, un programme doit avoir un
point d’entrée :
 main ( void )
 Ce programme ne prend pas d’argument
 En C, quand le type de la valeur renvoyée n’est
pas mentionné, int est pris par défaut

Point d’entrée (2)
 main( void )
 Est équivalent à int main( void )
 Est différent de void main( void )
 Un bloc d’instructions est délimité par des
accolades ouvrantes et fermantes :
main( void )
{
/* instructions du programme */
}

 Un programme peut avoir des paramètres
main( int argc, char *argv[ ] )
 argc = argument count, le nombre
d’arguments fournis
 argv = argument values, un tableau de
chaînes de caractères contenant la version
texte des arguments
 argv[ 0 ] permet d’accèder au nom du
programme

 Remarque : l’utilisation des paramètres
d’appel argc et argv est typique des
systèmes UNIX où les programmes sont
principalement invoqués (lancés) à partir
d’un shell
 Cela a moins de sens sous Windows (en
mode graphique) bien que les shortcuts
permettent d’utiliser des arguments

 Il est également possible de récupérer les
variables de l’environnement accessibles
sur le Shell
main( int argc, char *argv[ ], char *envp[ ] )
 envp est un tableau de chaînes de caractères
mais sa dimension n’est pas fournie : il faut
tester la fin du tableau en testant le pointeur
sur un élément

Définition de fonctions
 Une fonction possède un type de retour, un
nom et des arguments ; une procédure est
une fonction qui ne renvoie rien (void)
 void procedure( int entier, float reel )
{
/* les instructions de la fonction */
}

Définition de fonctions (2)
 Si la fonction possède un type de retour,
c’est qu’elle doit retourner quelque chose…
 double fonction( int entier, float reel )
{
return x;
}

Mémoire des variables
 Dans une définition de fonction, il est
possible de définir des variables pour une
utilisation locale
 Ces variables seront supprimées / oubliées à
la fin de la fonction
 Pour garder la trace d’une variable d’un
appel à l’autre, il faut utiliser le mot clé
static

Mémoire des variables (2)
 double fonc( int entier, float reel )
{
int i = 0;
static int j;
return x;
}
 j n’est pas global mais fonc s’en souviendra

Structures de contrôle
 Un programme n’est rien sans structures de
contrôle
 Structures de contrôle nécessaires pour
 Les tests
 Les itérations

Structures de contrôle (2)
 Test basique
if( i < 0 )
i = 0;
 Pas de marqueur then
 Utilisation possible des accolades
if( i < 0 )
{
i = 0;
j = 1;
}

 Le traitement alternatif est mentionné par
else :
if( t == 0 )
i = 0;
else if( t == 1 )
i = 3;
else i = 6;
 Les parenthèses peuvent s’avérer utiles pour
clarifier les tests d’un programme !

 Test en cascade
switch( ch )
{
case 'O':
case 'o' : i = 1;
break;
case 'N' :
case 'n' : i = 0;
break;
default : erreurNormande();
}

 Le test en cascade s’effectue sur des char ou
des int (un char est un int !)
 Différentes conditions peuvent être
regroupées
 Un cas par défaut peut être mentionné
 Le break est nécessaire car la réalisation
d’une condition n’interrompt pas
l’enchaînement (une manière de faire du
side effect)

 Le if-then-else peut s’écrire de manière
compacte :
if( A )
B
Else C
Est équivalent à
( A ? B : C )

 Itération bornée (ou indexée)
for( initialisation ; condition d’arrêt ;
incrémentation )
{
/* instructions */
}
 L’initialisation est effectuée avant le début
de la première itération

 La condition d’arrêt est testée avant
l’exécution de la première instruction du
bloc à chaque itération
 L’incrémentation est effectuée à la fin de
chaque itération
 Chacune de ces 3 parties est optionnelle !
Un break permet également de stopper
l’itération

 Utilisation typique :
for( i = d ; i < f ; i += p )
{
/* instructions */
}
 Cette structure de contrôle peut être très
efficace. Il faut cependant faire attention en
utilisant ses spécificités.

 Itérations non bornées
 Itération « tant que »
while( condition )
{
/* instructions */
}

 Itération « jusqu’à »
do
{
/* instructions */
}
while( condition )

Commentaires
 Commentaires
 Ils sont vivement conseillés dans les
programmes !
 Début avec /*
 Fin avec */
 Tout, TOUT, ce qui est entre un début et une
fin de commentaires est un commentaire, même
un bout de code malencontreusement déplacé !

Inclusions
 La mise à disposition de cet ensemble
d’instructions ne suffit pas pour développer
rapidement un programme
 Besoin de librairies de fonctions prédéfinies,
tenant compte si nécessaires des spécificités de
la plate-forme
 Utilisation de directives d’inclusion
#include <stdio.h>
#include <stdlib.h>

Inclusions (2)
 C permet d’utiliser (et d’inclure) deux types
différents de librairies
 Les librairies standards du système
#include <stdio.h>
 Ceci permet de faire le lien avec des programmes
précompilés du système
 Les librairies propres au développeur
#include "monfichier.h"
 Ceci permet de définir des librairies personnelles,
dont il faudra fournir le code

Inclusions (3)
 Les inclusions permettent de référencer des
fonctions définies par ailleurs ou d’utiliser
des constantes
 Pour utiliser des variables définies dans un
autre programme, il faut préciser qu’elles
sont externes
extern int i;
la variable i est réellement définie dans un autre
programme (fichier)

Extensions des noms
 Conventions de nommage des fichiers
 Le nom d’un fichier contenant une partie d’un
programme écrit en C comporte l’extension .c
 Le nom d’un fichier contenant un ensemble de
déclarations de constantes ou de déclarations de
fonctions (les signatures) se termine par .h
(ceux que l’on utilisent avec #include)
 Par extension, en C++ :
 .cpp, .cxx, .cc
 .hpp, .hxx, .hh

Importation
 #import
 Directive Microsoft
 Permet d’importer une DLL correspondant à la
définition d’un composant Microsoft ActiveX
 N’existe que sur les plate-formes Windows
 Depuis Visual C++ 5.0

Directives compilateur
 Il est possible d’influer sur le comportement
d’un compilateur en lui fournissant des
paramètres
 Certains de ces paramètres peuvent être des
variables littérales lui demandant d’avoir un
certain comportement lorsqu’il analyse le
code source
 Ces paramètres sont des définitions utilisées
par le préprocesseur

Directives compilateur (2)
 #define
 Permet de définir des variables littérales dans le
code source, en plus des définitions passées au
compilateur
 #define PI 3.14
 #define MAX( A, B ) (((A)>=(B)) ? (A) : (B) )
 #undef
 Permet de supprimer une déclaration

 #ifdef
 Code source à prendre en compte si un littéral
est défini
 #ifndef
 Code source à prendre en compte si un littéral
n’a pas été défini

 Ces déclarations de variables compilateur
sont en partie utilisées pour permettre le
portage d’un plate-forme à une autre ou
d’un système d’exploitation à un autre
 Il faut se rappeler que les résultats d’un
programme C peuvent varier en fonction de
la taille des mots du processeur

 #pragma
 Permet également d’agir sur le processeur et
d’utiliser certaines options de compilation
plutôt que d’autres
 Par exemple, cela permet de spécifier un jeu
d’instructions machine
 Support MMX
 Pentium 2, 3, 4
 etc

Débogage
 #assert
 Permet d’enclencher des mécanismes
d’assertion dans un programme en cours
d’exécution
 Il y a en fait plusieurs manières de faire, cet
indicateur est une des possibilités offertes par
certains compilateurs
 Nous y reviendrons plus tard

C++
Quelques ajouts de C++

Classes
 Mot clé principal : class
 Même s’il n’est pas toujours très objet, C++ a
des classes, la base de la programmation objet
 Les classes ne montrent pas toujours la
totalité de ce qu’elles savent faire :
 Il existe des qualificatifs permettant de dire qui
a le droit de voir et qui ne le pourra pas
 Ces qualificatifs s’appliquent aux variables et
aux fonctions

Classes (2)
 public : tout le monde peut voir, accèder et
modifier
 protégé (protected) : seule la descendance,
dans l’arbre d’héritage, a accès à ces
variables et fonctions (par héritage !)
 privé (private) : seuls les objets du type de
la classe elle-même ont accès à des
variables et des fonctions privées

Classes (3)
 Ces types de protection sont à la base de
tous les langages à objets
 mais il en manque un en C++
 C++ n’a pas décidé d’être l’archétype des
langages à objet, il se veut plus pragmatique
(rustique ? sale ?)
 C++ utilise public, private et protected mais
permet à certains objets d’accèder aux parties
les plus intimes d’un autre

Classes (4)
 Pour qu’un objet soit capable d’accèder aux
parties privées d’un autre objet, il doivent
être amis
 Mot clé friend : si une classe en déclare une
autre friend, elle la laisse accèder à tout
 Elle redéfinit en quelque sorte tout en public
pour certaines classes
 Cela peut être très dangereux…

Classes (5)
 Le mot clé friend est considéré comme le
goto des mécanismes objet de protection
des accès…
 Risque de couplage très fort dans un
système : très difficile à faire évoluer
ensuite.
 Peut être partiellement éviter par l’usage de
fonctions inline (équivalent au #define de
fonctions)

Classes (6)
 Pour la terminologie C++ :
 Une variable est généralement qualifiée de data
member
 Une méthode est généralement qualifiée de
member function

Classes (7)
 C++ simplifie quelque peu la gestion de la
mémoire dans le tas
 Il n’est plus nécessaire d’utiliser malloc et
free
 malloc peut être remplacé par new
 free peut être remplacé par delete
 Il y a alors un embryon de gestion
automatisé de la mémoire

Classes (8)
 C++ permet d’utiliser const sur des classes :
cela a parfois son utilité
 Mais toutes les variables d’une telle classe
ne sont pas obligées de rester constantes
 mutable permet de préciser qu’une partie d’un
const est modifiable

Classes (9)
 Dans le code source d’une classe, il est
possible de considérer l’instance qui sera
produite à partir de la classe (définition)
 Ce bloc mémoire peut être référencé par un
pointeur (c’est du C)
 L’objet dans lequel on se trouve possède un
nom spécial : this
 C’est celui que l’on est en train de parcourir

Classes (10)
 Certaines classes sont trop abstraites pour
avoir des instances
 Il est possible d’avoir des chevaux et des
dauphins
 Il est beaucoup plus dur d’avoir des instances
de mammifères bien que la classe (et sa
définition) existe

Classes (11)
 L’abstraction peut se traduire par
l’impossibilité de définir certaines fonctions
dans certaines classes et de savoir pourtant
que ces fonctions existeront
 Tous les mammifères se déplacent et la
présence de la fonction déplacer() dans la
classe mammifère a un sens
 Trouver le traitement correspondant est
beaucoup plus dur pour l’instant

Classes (12)
 Il est donc possible de dire qu’une fonction
est abstraite et de reléguer son
implémentation à une étape ultérieure, dans
une autre classe qui héritera de la classe
abstraite
 Dans mammifère
 virtual int déplacer();
 Dans la classe cheval, il sera possible de
donner le contenu effectif de la méthode

Classes (13)
 Il est possible de créer des espaces de
nommage et de les utiliser
 using namespace std;
 Utilisation de l’espace de nommage standard,
autrement dit l’espace de nommage comportant
les fonctions standard

Classes (14)
 Il fut un temps, en C++, où les espaces de
nommage n’existaient pas
 Pour résoudre certains problèmes, il était
possible (et il est encore possible)
d’effectuer des déclarations de classes
imbriquées
 Cela s’appelle les nested classes

Classes (15)
Class Externe {
public:
class InterneVisible { /* … */ }
private:
class InterneCachée { /* … */ }
}

Classes (16)
 Cela ne s’utilise pas n’importe comment !
 Externe ext; // OK
InterneVisible intvis1; // erreur
InterneCachée intcach1; // erreur
Externe::InterneVisible intvis2; //OK
Externe::InterneCachée intcach2; // err
 L’imbrication n’existe que pour des
problèmes de visibilité

Classes (17)
 Utilisation de l’héritage :
 class Forme {
public: /* … */
};
class Rond : public Forme {
// un rond est une forme
};

Classes (18)
 Définition d’une classe :
class A {
int i, j, k; // private par défaut
public:
int f();
void g();
}

Classes (19)
int B::f() {
return i + j – k;
}
void B::g() {
i = j = k =0;
}

Classes (20)
 Les commentaires ont été modifiés
 Il est toujours possible de commenter par
bloc avec /* … */
 Il est aussi possible de commenter sur une
ligne avec //
 Tous les caractères jusqu’au retour chariot font
partie du commentaire

Classes (21)
 C++ est un langage orienté objet qui
supporte la programmation générique (ce
qui n’a rien avoir avec l’objet…)
 Il est possible de définir des classes
template : un type d’objet devient alors
variable à l’intérieur d’une autre classe qui
est alors une classe paramétrée
 Définition d’une classe avec une variable de
substitution

Classes (22)
 template<class T>
class Array {
int size = 100; // ~
T A[ size ];
public:
T& operator[] ( int index ) {
return A[ index ];
}
};

Questions / Remarques

Cours de C++, en français, 2002 - Cours 1.2

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Cours de C++, en français, 2002 - Cours 1.2

Similaire à Cours de C++, en français, 2002 - Cours 1.2 (20)

Plus de Laurent BUNIET

Plus de Laurent BUNIET (9)

Cours de C++, en français, 2002 - Cours 1.2