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

Cours C++ (2002)
semaine 1
jour 5

Cours semaine 1 jour 5 Cours C++ 2
Plan du jour
 Surcharge de fonctions
 Constantes et pointeurs en C et C++
 Utilisation du préprocesseur

Surcharge de fonctions
 Parfois, dans l’univers quotidien, un même
mot peut signifier plusieurs choses
différentes
 Polysémie (pour les noms dans ce cas)
 De même, un verbe peut avoir plusieurs
sens et représenter des actions différentes
 Polysémie (pour les verbes cette fois)
 Polymorphisme chez les objets

Surcharge de fonctions (2)
 Dans un système orienté objet, le
polymorphisme indique qu’un même appel
de fonction se traduira par l’exécution
possible de traitements différents, en
fonction du contexte
 Cependant, dans le cas du polymorphisme,
il s’agit de fonctions ayant toujours la même
signature
 seDéplacer( float mètres );

 Il est possible, en C++, de définir plusieurs
fois une même fonction
 C’est à dire d’utiliser plusieurs fois le même
nom de fonction
 Cependant, cette possibilité est
indissociable de la condition que chacune
des fonctions doit avoir des arguments
différents

 En reprenant l’exemple du déplacement, un
classe pourra offrir autant de fonctions de
déplacement que de types possibles
 seDéplacer( float mètres ),
 seDéplacer( double mètres ),
 seDéplacer( int mètres ),
 seDéplacer( long mètres ),
 seDéplacer( Longueur mètres ),
 Etc.

 Cette possibilité de définir plusieurs
fonctions avec des arguments de type
différent s’appelle la surcharge de fonction
 Et ce n’est pas le polymorphisme…
 Cette surchage ne se limite pas aux
opérations à un argument mais il y a des
limites à tous. Ceci ne marche pas :
 seDéplacer( int mètres, int angle );
 seDéplacer( int angle, int mètres );

 Attention ! C et C++ sont des langages
typés (il y a des types) mais le typage est
faible (il y a quand même des void, y
compris sur les pointeurs…)
 S’il est possible d’avoir une surcharge sur
les fonctions par les arguments, il est
cependant impossible d’avoir une surcharge
sur les types de retour

 La surcharge sur les types de retour n’est
pas autorisée car il n’est après tout pas
obligatoire de tenir compte de la valeur de
retour d’une fonction…
 Le type de la partie gauche d’une affectation
serait un bon mécanisme de sélection mais cette
partie gauche n’existe pas obligatoirement :
 void f(); n’aura jamais de partie gauche !
int f();

#include <iostream>
using namespace std;
int f( int i )
{
return i * 2;
}
void main()
{
int i;
i = f( 3 );
cout << i << endl;
f( 4 ); // même pas de warning !
cout << i << endl;
i = f( 5 );
cout << i << endl;
}

 Nous avons déjà vu l’overloading de
fonction !
 Rappeler vous, hier, Vektor possédait deux
constructeurs qui renvoyaient tous les deux des
Vektor mais avait des arguments différents
 L’overloading de fonctions du C est une
bonne chose de C/C++ mais complique
parfois l’apprentissage des librairies !

Constantes
 En C, les constantes se définissent avec la
directive de précompilation #define
 #define PI 3.14159265358979323846
 Lors de la phase de précompilation, le
préprocesseur remplace la première chaîne
« PI » par « 3.14159… » à chaque fois que
« PI » est rencontré dans un fichier
 Le remplacement se fait mot pour mot, de
manière bête et méchante

Constantes (2)
 Le problème majeur du #define correspond
à ce remplacement direct et volontairement
« à l’aveugle »
 Un #define ne comporte AUCUN
renseignement de typage
 La possibilité de définir des constantes non
typées dans un langage typé est finalement
assez problématique

Constantes (3)
 C++ résoud le problème en introduisant le terme
const qui signifie qu’une définition de variable
correspond à une valeur fixe nommée (comme
dans le #define) et typée
 const float pi = 3.14159265358979323846;
 Attention, les constantes sont désormais définies
comme des variables mais ne sont pas pour autant
globales même si elles sont dans des fichiers
d’include
 On peut les inclure plusieurs fois !

Constantes (4)
 Il est aussi possible de définir des pointeurs
constants
 Exemple : un pointeur invariable sur un int (lire
les définitions de la droite vers la gauche)
 const int* ip;
 Un pointeur sur un const int : le pointeur peut changer, mais
pas l’entier pointé !
 int const* ip2;
 Un pointeur vers un entier invariable
 int* const ip3;
 Un pointeur invariable vers un int, enfin…

Constantes (5)
 Il est possible de passer des arguments
invariables à une fonction
 Cela permet d’être sûr qu’ils ne seront pas
modifiés (c’est vérifié pendant la compilation)
 void f( const int* i )
 Le paramètre i doit être considéré comme une
constante par f

Constantes (6)
 Le spécifieur const est applicable aux types
de base et aux pointeurs.
 Il est également applicable dans les classes
et « aux classes »
 Certaines variables d’une classe peuvent être
des constantes
 Certains objets (instances d’une classe) peuvent
être constants

Constantes (7)
 Les constantes dans les classes
 Certaines données d’une classe peuvent être
considérées comme constantes. Il faut
cependant parfois les initialiser !
 Ceci se fait de manière assez bizarre : il faut
appeler le constructeur du type constant, même
s’il s’agit d’un type de base !

Constantes (8)
class Test
{
const int size;
public:
Test( int sz );
void getSize();
};
Test::Test( int sz ) : size( sz )
{}
void Test::getSize()
{
cout << size << endl;
}
#include <iostream>
void main()
{
Test tt( 4 );
tt.getSize();
}

Constantes (9)
 Les objets peuvent aussi être définis comme
constants
 Cependant, pour garantir la constance des
objets, il faut garantir que certaines
méthodes ne modifient pas les variables
internes et qu’elles sont donc applicables
aux objets constants

Constantes (10)
class Test2 {
int size;
public:
Test2( int sz );
int getSize() const;
void setSize( int s );
};
Test2::Test2( int sz ) : size( sz )
{}
int Test2::getSize() const {
return size;
}
void Test2::setSize( int s ) {
size = s;
}

Constantes (11)
#include <iostream>
void main()
{
Test2 t1( 2 );
const Test2 t2( 3 );
cout << t1.getSize() << endl;
t1.setSize( 4 );
t2.setSize( 6 ); // ne compile pas !
}

Constantes (12)
 Mais voilà, parfois, on veut pouvoir changer
même ce qui est constant…
 En C/C++ : flexibilité et pragmatisme…
 Il est possible de dire que des variables
internes d’un objet constant peuvent
changer à l’aide du mot clé mutable

Constantes (13)
class Test2
{
int size;
mutable int i;
public:
Test2( int sz );
int getSize() const;
int getNum() const;
void setSize( int s );
};
Test2::Test2( int sz ) : size( sz ), i( 0 )
{}
int Test2::getSize() const
{
i++; // const !
// mais mutable…
return size;
}
int Test2::getNum() const
{
return i;
}
void Test2::setSize( int s )
{
size = s;
}

Constantes (14)
#include <iostream>
void main()
{
Test2 t1( 2 );
const Test2 t2( 3 );
cout << t1.getSize() << " " << t1.getNum() << endl;
t1.setSize( 4 );
//t2.setSize( 6 ); // toujours pas possible (const pas mutable)
}

Constantes (15)
 Les #define permettaient de définir des
valeurs constantes mais également des
fonctions « constantes »
 C++ offre const pour les valeurs
 C++ offre inline pour les fonctions
 Version appauvrie mais bien plus sûre du
#define

Constantes (16)
 Les fonctions inline ne doivent cependant
pas être utilisées de manière abusive :
 Elles ont tendance à réduire les performances,
 Elles permettent de contourner un mauvais
design
 Leur réplication par copier/coller peut apporter
de nombreux problèmes (comme d’habitude
avec le copier/coller…)
 Pas utilisable ailleurs que dans le fichier

Constantes (17)
#include <iostream>
using std::cout;
using std::endl;
inline void f( int i )
{
cout << "inline f sur " << i << endl;
}
void main()
{
f( 1 );
}

Constantes (18)
 Les fonctions peuvent également avoir des
valeurs par défaut dans leur signature
 Pour les types élémentaires sauf les pointeurs et
pas pour les classes !
 Les valeurs par défaut se mettent dans les
signatures des headers ou dans les
définitions de fonction
 float p( float r = 2.0f )
 Si aucune valeur n’est fournie, alors 2.0f

Pointeurs
 Les pointeurs sont assez compliqués à
suivre et méritent la plus grande attention
 Ils sont à l’origine de la majorité des problèmes
en C et C++
 Remarque : "int* i" est équivalent à "int *i"

Pointeurs (2)
 Nous avons vu que les pointeurs permettent
de passer la référence à une variable (une
case mémoire) plutôt qu’une copie de cette
variable
 Les pointeurs permettent le passage par
référence, plus efficace que le passage par
valeur
 Les pointeurs permettent également de
prédéfinir des variables dont il n’est pas
possible de connaître la taille a priori

Pointeurs (3)
 Lorsqu’une fonction passe l’adresse d’une
variable à une autre fonction, elle prend des
risques
 La fonction appelée peut faire n’importe quoi
 Elle peut donc détruire toute la zone appelée de
manière irrémédiable alors qu’elle devait
officiellement n’en modifier qu’une petite
partie
 Le passage par valeur peut alors s’avérer
utile…

Pointeurs (4)
 Cependant, le passage par valeur doit
normalement avoir lieu avec des types de
base
 Si une fonction stockait uniquement un
pointeur dans sa définition avant de réserver
un bloc de mémoire, il faudrait fournir la
copie du bloc mémoire en plus des types de
base
 Cela a l’air bien compliqué !

Pointeurs et copie
 C++, en plus des fonctions de base de
construction et de destruction de classe,
fournit un moyen de créer des copies de
l’objet courant en utilisant une fonction
« par défaut » supplémentaire :
 Le copy constructor, constructeur de copie
 Le nom de la fonction reprend le nom de la
classe, de même que le nom de l’argument

Pointeurs et copie (2)
 Si vous travaillez avec une classe X et avez
besoin d’un copy constructor, vous pouvez
le définir avec les constructeurs et
destructeurs
 X::X() // constructeur
 X::~X() // destructeur
 X::X(const X& x ) // constructeur de copie
 L’opérateur est connu sous le sobriquet de
X(X&)

#include <fstream>
#include <string>
ofstream out( "MaClasse.txt" );
class MaClasse
{
public:
string name;
static int objectCount;
MaClasse( const string& id = "" ) : name( id )
{
++objectCount;
print( "MaClasse()" );
}

~MaClasse()
{
--objectCount;
print( "~MaClasse()" );
}
// copy constructor
MaClasse( const MaClasse& h ) : name( h.name )
{
name += " copy";
++objectCount;
print( "MaClasse( const MaClasse& ) - appel du copy const" );
}

void print(const string& msg = "") const
{
if( msg.size() != 0 )
out << msg
<< endl;
out << 't' << name << ": "
<< "objectCount = " <<objectCount
<< endl << endl;
}
};

int MaClasse::objectCount = 0;
// appel et retour PAR VALEUR :
MaClasse f( MaClasse maClasse )
{
maClasse.print( "argument maClasse dans f()" );
out << endl << "! sortie de f()" << endl << endl;
return maClasse;
}

void main()
{
MaClasse h( "h" );
out << endl << "! h2 appel de f()" << endl << endl;
MaClasse h2 = f( h );
h2.print( "! h2 apres appel de f()" );
out << endl << "! appel de f(),«
<< " pas de valeur de retour" << endl << endl;
f( h );
out << endl << "! apres appel de f(),«
<< " pas de valeur de retour" << endl << endl;
}

Directives
 Les directives utilisables avec un
préprocesseur C/C++ sont standardisées
dans leurs bases
 Chaque compilateur pourra cependant en
offrir d’autres supplémentaires
 C’est bien sûr le cas de la plate-forme
Microsoft

Directives (2)
 Il existe trois conditionnelles de
précompilation :
 #if expression
 Permet de tester une constante ou une expression
 #ifdef expression
 Permet de tester l’existence d’un identifiant
 #idndef expression
 Permet de tester l’inexistence d’un identifiant

Directives (3)
 La directive #ifdef ou #ifndef sont des
contractions de #if « test »
 #if defined( __EXPRESSION__ )
est équivalent
à #ifdef __EXPRESSION__
 #if !defined(__EXPRESSION__ )
est équivalent à
#ifndef __EXPRESSION__

Directives (4)
 Comme nous sommes en train de réaliser
des tests, d’autres possibilités existent
 #else
 #elif (else if)
 #endif

Directives (5)
 À partir de ces conditionnelles, il est par
exemple possible d’inclure dans le
programme certaines parties de code plutôt
que d’autres :
 #ifdef __MY_MAIN__
int entierGlobal;
#else
extern int entierGlobal;
#endif

Directives (6)
 Ce genre de technique permet de ne
conserver qu’un seul fichier d’inclusion (les
.h) contenant la totalité des variables
globales, s’il y en a, et de distinguer les
traitements en fonctions du fichier source
 Le fichier source contenant la fonction main()
comportera par exemple, avant l’inclusion des
.h, une directive
 #define __MY_MAIN__

Directives (7)
 Les directives permettent d’influencer
l’écriture finale des fichiers source, elles
permettent également d’influencer les
traitements internes
 #line 24
 Dit qu’à partir de la ligne où se trouve le #line, nous
sommes à la ligne 24
 #line 24 "NouveauNom.c"
 Change la ligne courante et le nom apparent du
fichier, utilisé dans les messages d’erreurs

Directives (8)
 Il est également possible de créer des
erreurs de compilation
 #if !defined( __EXPRESSION__ )
#error Vous n’avez pas définit EXPRESSION
#endif

Directives (9)
 Enfin, il existe des directives permettant de
raffiner la compilation en fonction de la
machine sur laquelle on se trouve
 Prise en compte d’un système d’exploitation
particulier (il existe plusieurs versions de
Windows !)
 Prise en compte d’un jeu d’instructions
particulier : tous les processeurs n’offrent pas
les même possibilités (il existe plusieurs
processeurs chez Intel !)

Directives (10)
 Ces directives particulières sont identifiées
par #pragma
 C, et C++, sont après tout des langages
pragmatiques…
 Les #pragma permettent de s’enfoncer au
cœur du processus de transformation du
code C/C++ en assembleur qui sera ensuite,
pendant la phase d’édition de lien,
transformer en langage machine

Directives (11)
 #pragma alloc_text permet de modifier le
nom assembleur des fonctions
 Typiquement, f( int x ) se traduit normalement
en _f_int. Cela peut se changer…
 #pragma auto_inline permet de modifier le
traitement des fonctions inline
 Cela revient presque à dire que l’on ne veut pas
appliquer tel que l’équivalent inline de #define
MAX( A, B )

Directives (12)
 #pragma bss_seg permet de regrouper
toutes les variables non initialisées dans un
même bloc. Cela accélère le temps de
chargement
 #pragma check_stack permet de modifier
le processus de vérification de la pile, pour
les parties de code n’utilisant pas le tas

Directives (13)
 #pragma code_seg permet de spécifier
l’endroit où l’on veut stocker les morceaux
de code des fonctions
 #pragma const_seg permet de spécifier
l’endroit où l’on veut stocker les constantes
du programme
 Crée un segment read-only

Directives (14)
 #pragma comment permet de placer un
commentaire dans le fichier assembleur (!).
À utiliser dans le cas où l’on vous retire la
licence Visual Dev…
 #pragma component permet d’influer sur
la collecte des informations dans le code
source C++
 #pragma component( minrebuild, off ) permet
de supprimer le minimum rebuild dans Visual
C++ (et les informations associées)

Directives (15)
 #pragma data_seg permet de regrouper
toutes les variables dans un même bloc.
Cela accélère le temps de chargement
 #pragma function permet d’influer sur le
traitement du code. Il force la création
d’appels de fonction plutôt que l’utilisation
d’inline. Cela influe sur l’espace disque du
programme compilé

Directives (16)
 #pragma hdrstop influe sur le traitement
des fichiers d’inclusion précompilés
 #pragma include_alias permet de résoudre
les problèmes 8.3 de la FAT
 #pragma init_seg dit comment le code de
chargement du programme en mémoire est
exécuté

Directives (17)
 #pragma inline_depth permet de contrôler
le ratio accepté d’inline ou d’appel de
fonction. Influe sur la taille du programme
et le temps d’exécution (compromis
espace/temps).
 #pragma inline_recursion influe sur la
réécriture en inline ou en fonction des
fonctions récursives (compromis
espace/temps)

Directives (18)
 #pragma intrinsic dit au compilateur de
générer les opérations intrinsèques en inline
ou en fonction (espace/temps). Par exemple,
s’applique à la fonction de calcul de la
valeur absolue abs( int ).
 #pragma message affiche un message à
l’écran pendant l’exécution de la
compilation

Directives (19)
 #pragma once indique au compilateur de
n’ouvrir un fichier qu’une fois pendant la
compilation
 Regardez le contenu d’un fichier StdAfx.h…
 #pragma optimize pour indiquer un mode
d’optimisation du code. Plusieurs options.
 #pragma pack permet d’aligner des
structures de données sur un nombre
d’octets spécifiques

Directives (20)
 #pragma pointers_to_members permet de
modifier le traitement des pointeurs vers les
data members d’une classe
 #pragma setlocale permet de spécifier le
jeu de caractères « ASCII » à utiliser pour la
compilation. Permet d’avoir un support pour
les jeux de caractères nationaux.

Directives (21)
 #pragma vtordisp influe sur l’appel de fonctions
d’une classe fille vers la classe mère, dans le cadre
de l’héritage (une fille peut redéfinir une fonction
de la classe mère et tout de même appeler la
fonction de la classe mère pour réaliser certains
traitements)
 #pragma warning modifie le comportement du
compilateur pour le traitement des warning
(erreurs non fatales à la compilation)

Questions / Remarques

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

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

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

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

Plus de Laurent BUNIET

Plus de Laurent BUNIET (11)

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