Cours - LUTH - Observatoire de Paris

Le C++ 

Jérôme Novak 

Introduction 

Motivations 

Les cours 

Quelques bases 

Les classes 

Syntaxe 

Les types 

Les fonctions 

Les instructions 

Pointeurs 

Entrées/Sorties 

Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 

Héritage simple 

Hér. multiple 

Polymorphisme 

≪ En 

pratique ≫ 

Références 

Le langage C++: 

comment ça marche? 


Jerome.Novak@obspm.fr 

http://luth.obspm.fr/~luthier/novak 

Laboratoire Univers et Théories (LUTH) 

CNRS / Observatoire de Paris / Université Paris Diderot 

Master 2 e année recherche, Septembre 2012

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Plan 

1 Introduction : Pourquoi le C++ ? 

2 La syntaxe (premiers pas) 

3 Les classes : orientation objet 

4 Héritage et polymorphisme 

5 ≪ En pratique ≫ 

6 Pour aller plus loin ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Plan 







Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Plan 







Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Plan 







Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Plan 







Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Plan 







Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Introduction 

1 Pourquoi le C++ ? 

2 État des lieux 

3 Quelques notions pour démarrer 

4 Un avant-goût des classes

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Intérêt du C++ ? 

langage orienté objet 

gestion dynamique de la mémoire 

écriture du code très rigoureuse 

possibilité d’incorporer des routines en C ou fortran 

possibilité de compiler les programmes C, avec le 

compilateur C++ 

compilateurs disponibles et fiables (même gratuits !) 

norme respectée (norme 2011 ?) 

nombreuses bibliothèques 

existence d’outils pour le développement, l’optimisation, ... 

(Purify/Electric Fence/Valgrind, Doxygen,...)

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Pour et contre... 

⇒ Pour pouvoir gérer les codes complexes 

⇒ Pour travailler à plusieurs sur un même projet 

(collaborateurs, visiteurs, ...) 

⇒ Pour réduire le temps de développement, de correction et 

de tests 

Mais 

Apprentissage long 

et complexe 

Légère perte en 

vitesse d’exécution

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 







Mais 


et complexe 



Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 







Mais 


et complexe 



Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 







Mais 


et complexe 



Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

... et ça marche ! 

Certains codes n’auraient jamais pu être écrits en fortran ou 

en C...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Une organisation possible 

pour un projet complexe 

Python, perl, . . . 

Organisation des codes : données initiales, évolution, 

post-traitement, gestion des entrées/sorties complexes, 

affichage, visualisation, . . . 

C++, java, . . . 

⇑ 

Organisation des objets : concepts mathématiques / physiques, 

structures de stockage, grands groupes d’opérations, . . . 

C, fortran, . . . 

Opérations élémentaires : algèbre linéaire, transformées de 

Fourier, Newton-Raphson, . . . 

⇑

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 







C++, java, . . . 

⇑ 






⇑

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 







C++, java, . . . 

⇑ 






⇑

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Quelques documents utiles 

Un serveur de documents et de ressources sur le C/C++ : 

www.cplusplus.com/main.html ; 

Le cours de C++ du Laboratoire Jacques-Louis Lions 

(labo d’analyse numérique de Jussieu) sur 

www.ann.jussieu.fr/courscpp. 

LE manuel de référence : Le langage C++, de Bjarne 

Stroustrup, Eds. Vuibert. 

Un livre très complet : Langage C++ – Le standard 

ANSI/ISO expliqué, de Jacquelin Charbonnel, Eds. Dunod. 

Mon petit poly en anglais : 

www.lorene.obspm.fr/cpp digest.pdf.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Où va-t-on ? 

un cours théorique (∼ 8 h), 

des TP d’application directe et de familiarisation (∼ 8 

h), 

des TP de conception de codes plus élaborés, qui 

seront éventuellement utilisés pour le projet de 

modélisation numérique (s’il reste du temps ! !). 

... le tout mélangé au cours des séances. 

Objectif des TP ≪ élaborés ≫ : 

Résoudre une équation différentielle du second ordre à 

coefficients constants avec second membre.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Où va-t-on ? 

un cours théorique (∼ 8 h), 

des TP d’application directe et de familiarisation (∼ 8 

h), 

des TP de conception de codes plus élaborés, qui 

seront éventuellement utilisés pour le projet de 

modélisation numérique (s’il reste du temps ! !). 

... le tout mélangé au cours des séances. 

Objectif des TP ≪ élaborés ≫ : 

Résoudre une équation différentielle du second ordre à 

coefficients constants avec second membre.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

État des lieux 

compilateur (compilation, lien) 

système Unix/Linux (base, éditeur, makefile, 

...) 

programmation (pointeurs, programmation 

orientée objet) 

C++ ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 




...) 



C++ ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 




...) 



C++ ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 




...) 



C++ ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 




...) 



C++ ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Quelques notions pour démarrer 

programme/sous-programme → fonctions en C/C++ 

variables 

types 

pointeurs 

références 

tableaux 

fonctions 

allocation dynamique de mémoire 

et des conventions : 

déclaration 

définition 

concepteur/utilisateur

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Quelques notions pour démarrer 

programme/sous-programme → fonctions en C/C++ 

variables 

types 

pointeurs 

références 

tableaux 

fonctions 

allocation dynamique de mémoire 

et des conventions : 

déclaration 

définition 

concepteur/utilisateur

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Illustration 

Un code qui ne sert à rien : exemple1.cpp 

// headers C++ 

#include 


// headers C 



// // headers maison 

#include "ma_fonction.h //Il faut mettre la les fichiers declarant 

//des fonctions et classes qui ne font pas 

//partie du systeme. 

using namespace std ; 

/* Ce programme ne fait pas 

grand chose, sinon de montrer 

une syntaxe "de base" */ 

int main(){ 

const int nmax = 200 ; 

double tableau1[nmax] ; 

char dim[] = "taille" ; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Illustration 

Un code qui ne sert à rien : exemple1.cpp 

if ((taille200)) { 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Illustration 

Un code qui ne sert à rien : ma fonction.h 

// declaration seule d’une fonction 

double ma_fonction(double , int) ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

TP n o 1 

Le programme ≪ bonjour le Monde ! ≫ 

Objectifs : 

1 se familiariser avec l’environnement... 

2 compiler avec un Makefile 

3 écrire et exécuter un programme affichant 

une phrase et effectuant un calcul après 

l’entrée des données par l’utilisateur 

4 éventuellement, ce programme construira un 

tableau de taille donnée par l’utilisateur au 

moment de l’exécution

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

C++ C amélioré ? 

⇒pas seulement ! 

langage très typé, même pour les pointeurs 

utilisation de références 

surcharge de fonctions 

utilisation de classes... 

... et de ≪ patrons ≫(modèles) de classes, de 

fonctions.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les classes : le début 

Une classe contient des données (variables de types pré-définis 

ou autres classes) et des fonctions. Elle est la généralisation du 

concept de type dans les langages informatiques. 

Pour les classes simples, les données représentent l’information 

contenue dans la classe et les fonctions décrivent à l’ordinateur 

la façon de la gérer. 

Il existe quatre fonctions ≪ obligatoires ≫ : 

le constructeur par défaut 

le constructeur par recopie 

le destructeur 

l’opérateur d’affectation

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

// Declaration de la classe "Ma_classe" 

#ifndef __MA_CLASSE_H_ // Pour eviter les declarations multiples 

#define __MA_CLASSE_H_ 


#include // Eventuellement , , ... 



// + headers perso s’il y en a ... #include "???" 


class Ma_classe { 

// Donnees : 

protected: 

int entier_membre_1 ; double reel_membre_1 ; //etc... 

// Constructeurs 

public: 

Ma_classe(char*, int, double, ...) ; // Constructeur standard 

Ma_classe(const Ma_classe& ) ; // Constructeur par copie 

// Destructeur 

virtual ~Ma_classe() ; 

// Operateur d’affectation 

void operator=(const Ma_classe&) ; 

// Affichage (non obligatiore, mais tres utile) 

friend ostream& operator

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

// Definition de Ma_classe 

// headers perso : les headers C++ / C sont inclus dans ma_classe.h 

#include "ma_classe.h" 

// Constructeur 

Ma_classe::Ma_classe() { // Eventuellement avec des parametres 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les classes : un exemple 

Une classe Fiche contient : 

le nom ⇒de type ≪ chaîne de caractères ≫ (char*) 

le prénom ⇒de type ≪ chaîne de caractères ≫ (char*) 

l’âge ⇒de type entier (int) 

le numéro ⇒de type entier (int)

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

fiche.h 

// Declaration de la classe "Fiche" 

#ifndef __FICHE_H_ 

#define __FICHE_H_ 






class Fiche { 

// Donnees : 

protected: 

char* nom ; 

char* prenom ; 

int age ; 

int matricule ; 

// Constructeurs 

public: 

Fiche(const char* nom_i, const char* prenom_i, int age_i, 

int matricule_i) ; // Constructeur standard 

Fiche(const Fiche& fiche_arg) ; // Constructeur par copie 


virtual ~Fiche() ; 


void operator=(const Fiche& fiche_arg) ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

fiche.h 

// Acces aux donnees ... 

// ... en lecture seule 

const char* lit_nom() const ; 

const char* lit_prenom() const ; 

int lit_age() const ; 

int lit_matricule() const ; 

// ... en lecture / ecriture 

void change_nom(const char* nom_i) ; 

void change_prenom(const char* nom_i) ; 

void change_age(int age_i) ; 

void change_matricule(int matricule_i) ; 

// Affichage (non obligatiore, mais tres utile) 

friend ostream& operator

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

fiche.cpp 

// Definition de Fiche 


#include "fiche.h" 

// Constructeur 

Fiche::Fiche(const char* nom_i, const char* prenom_i, int age_i, int matricule_i): 

nom(0x0), prenom(0x0), age(age_i), matricule(matricule_i) 

{ 

int l_nom = strlen(nom_i) + 1; 

nom = new char[l_nom] ; 

strcpy(nom, nom_i) ; 

} 

int l_pnom = strlen(prenom_i) + 1 ; 

prenom = new char[l_pnom] ; 

strcpy(prenom, prenom_i) ; 

// Constructeur par Copie 

Fiche::Fiche(const Fiche & fiche_arg) : 

nom(0x0), prenom(0x0), age(fiche_arg.age), matricule(fiche_arg.matricule) 

{ 

int l_nom = strlen(fiche_arg.nom) + 1 ; 


strcpy(nom, fiche_arg.nom) ; 

} 

int l_pnom = strlen(fiche_arg.prenom) + 1 ; 


strcpy(prenom, fiche_arg.prenom) ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

fiche.cpp 


Fiche::~Fiche() { 

if (nom != 0x0) delete [] nom ; 

if (prenom != 0x0) delete [] prenom ; 

} 


void Fiche::operator=(const Fiche & fiche_arg) { 


int l_nom = strlen(fiche_arg.nom) + 1 ; 


strcpy(nom, fiche_arg.nom) ; 

if (prenom !=0x0) delete [] prenom ; 

int l_pnom = strlen(fiche_arg.prenom) + 1 ; 


strcpy(prenom, fiche_arg.prenom) ; 

age = fiche_arg.age ; 

matricule = fiche_arg.matricule ; 

return ; 

} 

const char* Fiche::lit_nom() const { return nom ; } 

const char* Fiche::lit_prenom() const { return prenom ; } 

int Fiche::lit_age() const { return age ; } 

int Fiche::lit_matricule() const { return matricule ; }

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

fiche.cpp 

void Fiche::change_nom(const char* nom_i) 

{ 


int l_nom = strlen(nom_i) + 1 ; 


strcpy(nom, nom_i) ; 

} 

return ; 

void Fiche::change_prenom(const char* prenom_i) 

{ 

if (prenom !=0x0) delete [] prenom ; 

int l_pnom = strlen(prenom_i) + 1 ; 


strcpy(prenom, prenom_i) ; 

} 

return ; 

void Fiche::change_age(int age_i) { age = age_i ; } 

void Fiche::change_matricule(int matricule_i) { matricule = matricule_i ; } 

// Affichage a l’ecran 

ostream& operator

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

programme principal 

Exemple 

// headers systeme 

#include 

// headers maison 

#include "fiche.h" 

int main(){ 

const int longueur = 30 ; 

char un_nom[longueur] ; 

cout > un_nom ; 

char un_prenom[longueur] ; 

cout > un_prenom ; 

cout > un_age ; 

cout > un_matricule ; 

Fiche f1(un_nom, un_prenom, un_age, un_matricule) ; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

TP n o 2 

une classe simple de rationnels 

1 construire une classe rationnel qui représente un nombre 

du type a/b, où a et b sont des entiers. 

2 doter la classe rationnel de l’arithmétique exacte des 

rationnels. 

3 être capable d’afficher le résultat d’un calcul du genre : 

rationnel(420,315) + 5 qui soit plutôt 19/3... 

Il faut commencer par concevoir la classe, ce qui se fait le 

mieux en écrivant les déclarations. 

⇒expliquer à l’ordinateur comment va fonctionner ce nouveau 

type.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

TP n o 2 

une classe simple de rationnels 

1 construire une classe rationnel qui représente un nombre 

du type a/b, où a et b sont des entiers. 

2 doter la classe rationnel de l’arithmétique exacte des 

rationnels. 

3 être capable d’afficher le résultat d’un calcul du genre : 

rationnel(420,315) + 5 qui soit plutôt 19/3... 

Il faut commencer par concevoir la classe, ce qui se fait le 

mieux en écrivant les déclarations. 

⇒expliquer à l’ordinateur comment va fonctionner ce nouveau 

type.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Le programme principal 


//Declarations of the class rational 

#include "rational.h" 

int main(){ 

} 

rational p(420,315) ; // 420/315, simplified 

// by the constructor 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Syntaxe (premiers pas) 

1 Les types de variables 

2 Les fonctions 

3 Les instructions 

4 Les pointeurs, références et allocation de 

mémoire 

5 Les entrées/sorties basiques 

6 Les constantes 

NB : tout ce qui marche en C, marche aussi en 

C++ !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Syntaxe (premiers pas) 

1 Les types de variables 

2 Les fonctions 

3 Les instructions 

4 Les pointeurs, références et allocation de 

mémoire 

5 Les entrées/sorties basiques 

6 Les constantes 

NB : tout ce qui marche en C, marche aussi en 

C++ !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les types de variables 

int annee=2002 ; 

float epsilon1=1e-8 ; 

double epsilon2=1e-16 ; 

char lettre=’w’ ; 

bool condition=true ; 

Les variables peuvent être déclarées à n’importe quel endroit du 

code, mais elles doivent toujours être déclarées avant leur 

utilisation. 

La portée d’une déclaration est locale, c’est-à-dire elle ne vaut 

que dans le bloc { ... } où elle a été faite.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les fonctions 

Tout doit être déclaré : 

double Tchebychev (double x, int degre) ; : 

d’abord dans les en-têtes (fichiers.h) de tous les 

programmes (routines) qui vont l’utiliser, ⇒déclaration 

(attention aux déclarations multiples !) 

puis elle doit être programmée dans un fichier.C (ou 

fichier.cpp). ⇒définition 

Si la fonction ne retourne rien (par exemple affichage) elle 

est de la forme void diagonalise (Matrice& T) ;. 

Les fonctions mathématiques (sin, cos, log, pow, exp, sqrt, 

fabs, ...) sont déclarées dans . 

On peut aussi définir une fonction dans le 

≪ fichier.h ≫(inline).

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Arguments par défaut 

Certains arguments d’une fonction peuvent prendre souvent la 

même valeur. 

Pour ne pas avoir à spécifier ces valeurs à chaque appel de la 

fonction, le C++ permet de donner des valeurs par défaut dans 

la déclaration de la fonction (ils doivent être mis à la fin de la 

liste !). 

void affiche(int valeur, int base = 10); 

void main() { 

affiche(16) ; // affiche 16 en base 10 

affiche(16,2) ; // affiche 16 en base 2 

} 

et dans la définition : 

void affiche(int valeur, int base) { ... }

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


for(i=0; i

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Pointeurs 

Un pointeur sur une variable est l’adresse en 

mémoire de cette variable : 

int g ; 

int *point = &g ; 

point contient l’adresse de g, il est de la forme 

0x0045a3f9 (en hexadécimal). 

En C++ un pointeur est typé : un int * n’est 

pas compatible avec un double *. 

Par défaut, un pointeur pointe sur 0x0 (pointeur 

nul)

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Tableaux 

Un tableau est un pointeur sur le premier 

élément. 

int tab[10]; ⇒tab est du type int * et 

contient l’adresse de du premier élément 

(tab[0]). 

Dans ce type de déclarations (double 

tab[N]), N doit pouvoir être calculé à la 

compilation (allocation statique). 

Avec : int *ptr = tab ; 

ptr++ ; 

que vaut ptr[0] ? 

NB : On peut définir int tab3[N3][N2][N1]

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Tableaux 

Un tableau est un pointeur sur le premier 

élément. 

int tab[10]; ⇒tab est du type int * et 

contient l’adresse de du premier élément 

(tab[0]). 

Dans ce type de déclarations (double 

tab[N]), N doit pouvoir être calculé à la 

compilation (allocation statique). 

Avec : int *ptr = tab ; 

ptr++ ; 

que vaut ptr[0] ? 

NB : On peut définir int tab3[N3][N2][N1]

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Gestion dynamique de la mémoire 

Pour avoir un tableau de taille définie au cours de 

l’exécution (par exemple, donnée par l’utilisateur), il faut 

faire des allocations dynamiques : 

type *tab dynamique ; 

tab dynamique = new type[un entier] ; 

Cet espace de la mémoire DOIT être rendu quand on ne 

s’en sert plus (à défaut, à la fin du programme) par : 

delete[] tab; 

Il n’y a aucun contrôle sur l’accès aux éléments d’un 

tableau. 

⇒la gestion dynamique de la mémoire est délicate. Il est 

bon de bien séparer les parties concepteur/utilisateur et d’ 

utiliser des outils de développement.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 











tableau. 




Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 











tableau. 




Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 











tableau. 




Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Références 

double a; double& ref a = a désigne une référence sur a, 

il s’agit d’un synonyme (ou équivalent) de a. 

Les références sont surtout utilisées pour passer des arguments 

aux fonctions, ou pour la valeur de retour des fonctions (à 

éviter). 

On ne peut pas déclarer int &a seul, mais on utilise : 

void swap(int &x, int &y) { 

int z = x ; 

x = y ; y = z ; } 

et dans le programme principal : 

int a=1; int b=2 ; 

swap(a,b) ; 

Contrairement aux pointeurs, toute modification de la référence 

modifie aussi l’objet original !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Références 

double a; double& ref a = a désigne une référence sur a, 

il s’agit d’un synonyme (ou équivalent) de a. 

Les références sont surtout utilisées pour passer des arguments 

aux fonctions, ou pour la valeur de retour des fonctions (à 

éviter). 

On ne peut pas déclarer int &a seul, mais on utilise : 

void swap(int &x, int &y) { 

int z = x ; 

x = y ; y = z ; } 

et dans le programme principal : 

int a=1; int b=2 ; 

swap(a,b) ; 

Contrairement aux pointeurs, toute modification de la référence 

modifie aussi l’objet original !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

valeur, pointeur et référence 

En C++, il existe trois façon d’accéder à une variable. Après 

avoir déclaré int a; soit 

par sa valeur 

a = 5; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 




par sa valeur 

a = 5; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 




par sa valeur 

a = 5; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Entrées et sorties simples 

Le C++ dispose de ≪ flots ≫d’entrées/sorties standard, 

déclarés dans (il faut aussi déclarer : 

using namespace std ;) 

cout qui correspond à la sortie standard (≪ à 

l’écran ≫), 

cin qui correspond à l’entrée standard. 

On écrira donc : 

int n; 

cout n ; "endl" est ici un manipulateur qui est 

équivalent à une fin de ligne.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les constantes 

Elles sont obligatoires pour les dimensions des tableaux 

non-dynamiques. 

Elles sont fortement conseillées pour protéger les 

variables en écriture. 

Plus concrètement : 

const double est un cas particulier de double. 

const int *ptr veut dire que la variable pointée est 

constante, mais pas l’adresse. Pour cela, il faut écrire 

int *const ptr 

const int& ref est similaire au cas des pointeurs : 

la variable référencée ne peut pas être modifiée à 

travers cette référence.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les constantes 

Elles sont obligatoires pour les dimensions des tableaux 

non-dynamiques. 

Elles sont fortement conseillées pour protéger les 

variables en écriture. 

Plus concrètement : 

const double est un cas particulier de double. 

const int *ptr veut dire que la variable pointée est 

constante, mais pas l’adresse. Pour cela, il faut écrire 

int *const ptr 

const int& ref est similaire au cas des pointeurs : 

la variable référencée ne peut pas être modifiée à 

travers cette référence.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les classes 

orientation objets 

1 Les membres : données et fonctions 

2 Les membres ≪ obligatoires ≫ 

3 Restrictions d’accès aux membres 

4 Surcharge de fonctions 

5 Membres constants 

6 TP n o 3 : une classe de stockage de réels

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Les membres 

données et fonctions 

Le programmeur peut définir ses propres ≪ types ≫et les 

fonctions qui leurs sont associées. 

Une classe Alpha est ainsi constituée : 

de données : variables, pointeurs, tableaux... ou d’objets 

d’autres classes ! 

et de fonctions. 

⇒Ce sont les membres de la classe Alpha. 

Les membres (données et fonctions) définissent une classe. 

La déclaration d’un objet de la classe s’appelle une instance de 

la classe.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Implémentation d’une classe 

Déclaration 

class Alpha { int entier1 ; // les données ... 

double reel1 ; 

Beta autre objet ; 

int *tableau ; //alloué dynamiquement par le 

constructeur ou une fonction membre 

... 

double fonction1(const int&) ; 

Alpha *fonction2(double, const Gamma&) ;}; 

Définition 

Si elle n’est pas dans le bloc de déclaration : 

double Alpha::fonction1(const int& i) { ... } et 

on peut utiliser le pointeur this ainsi que tous les membres.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Implémentation d’une classe 

Déclaration 

class Alpha { int entier1 ; // les données ... 

double reel1 ; 

Beta autre objet ; 

int *tableau ; //alloué dynamiquement par le 

constructeur ou une fonction membre 

... 

double fonction1(const int&) ; 

Alpha *fonction2(double, const Gamma&) ;}; 

Définition 

Si elle n’est pas dans le bloc de déclaration : 

double Alpha::fonction1(const int& i) { ... } et 

on peut utiliser le pointeur this ainsi que tous les membres.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Utilisation 

Dans le programme principal, l’utilisation d’une 

classe se fait de la manière suivante (après l’avoir 

déclarée) : 

Alpha a; //instance de Alpha 

Alpha *pta ; // pas instance de Alpha 

a.reel1 = 1.2 ; 

pta->entier1 = 37 ; 

double d = a.fonction1(3) ; 

const Gamma g; 

a = *pta->fonction2(3.4, g) ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Membres obligatoires 

Dans chaque classe il faut qu’il y ait 4 fonctions membres 

≪ spéciales ≫, sinon, elles seront créées par le compilateur... 

au moins un constructeur (autre que copie) 

un destructeur 

un constructeur par recopie 

un opérateur d’affectation (copie sans création) 

Il faut déclarer, puis définir ces fonctions membres, sauf si 

vous savez exactement ce que va faire le compilateur (et 

que ça vous va...).

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

constructeurs 

Ce sont les fonctions membres qui construisent les 

données (ils peut y en avoir plusieurs). 

Ils n’ont pas de type de retour (même pas void !). 

Ils portent le même nom que la classe qu’ils peuvent 

construire. 

Ils se différencient par la liste de leurs arguments. 

Initialiser les données membres sur l’en-tête du constructeur 

(liste d’initialisation) : 

Alpha::Alpha(double a, int n, const Beta 

&b):entier1(n), reel1(a), autre objet(b) { ... } 

Remarque : il n’est pas nécessaire que ce soit le constructeur 

qui alloue toute la mémoire dynamique de l’objet.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

constructeurs 

Ce sont les fonctions membres qui construisent les 

données (ils peut y en avoir plusieurs). 

Ils n’ont pas de type de retour (même pas void !). 

Ils portent le même nom que la classe qu’ils peuvent 

construire. 

Ils se différencient par la liste de leurs arguments. 

Initialiser les données membres sur l’en-tête du constructeur 

(liste d’initialisation) : 

Alpha::Alpha(double a, int n, const Beta 

&b):entier1(n), reel1(a), autre objet(b) { ... } 

Remarque : il n’est pas nécessaire que ce soit le constructeur 

qui alloue toute la mémoire dynamique de l’objet.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

copie et affectation 

constructeur par recopie 

C’est un constructeur de la forme : 

Alpha::Alpha(const Alpha&) { ... } 

qui recopie membre à membre. 

opérateur d’affectation 

Ce n’est pas un constructeur, il se contente de recopier les 

membres d’un objet dans ceux d’un autre existant déjà : 

Alpha::operator=(const Alpha&) { ...}

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

copie et affectation 

constructeur par recopie 

C’est un constructeur de la forme : 

Alpha::Alpha(const Alpha&) { ... } 

qui recopie membre à membre. 


Ce n’est pas un constructeur, il se contente de recopier les 

membres d’un objet dans ceux d’un autre existant déjà : 

Alpha::operator=(const Alpha&) { ...}

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

le destructeur 

Un destructeur est une fonction membre spéciale 

appelée automatiquement juste avant la destruction 

d’un objet. 

Il porte le même nom que la classe, précédé du signe ˜. 

Il n’a pas d’argument, ni de type de retour. 

Il donne au programme une dernière occasion de 

libérer la mémoire allouée à l’objet. 

Une classe ne peut avoir qu’un seul destructeur. 

Alpha::~Alpha() { ... }

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Restriction d’accès aux membres 

Tous les membres ne sont pas accessibles par l’utilisateur d’une 

classe. 

C’est le concepteur (programmeur) de cette classe qui décide 

quels membres pourront être manipulés directement par 

l’utilisateur. 

Il existe trois types d’accès : 

l’accès public : tout le monde a accès, 

l’accès protected : les fonctions membres de la classe et 

des classes dérivées ont accès, 

l’accès private : seules les fonctions membres de la classe 

ont accès. 

Il faut mettre le mot-clef correspondant au type d’accès avant 

les membres dans la déclaration de la classe (.h).

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Déclaration de type d’accès 

public: 

double fonction1... 

Ce type d’accès vaut pour tous les membres jusqu’à la 

rencontre d’un nouveau mot-clef. 

Par défaut, les membres sont privés. 

fonctions et classes amies 

Ce sont des fonctions (ou des classes) qui ont libre accès aux 

membres privés ou protégés. 

Elles sont déclarées au même endroit que les membres : 

friend double fonction pote(const char*) ; 

friend class Gamma ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Déclaration de type d’accès 

public: 

double fonction1... 

Ce type d’accès vaut pour tous les membres jusqu’à la 

rencontre d’un nouveau mot-clef. 

Par défaut, les membres sont privés. 

fonctions et classes amies 

Ce sont des fonctions (ou des classes) qui ont libre accès aux 

membres privés ou protégés. 

Elles sont déclarées au même endroit que les membres : 

friend double fonction pote(const char*) ; 

friend class Gamma ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Surcharge des fonctions 

Une fonction n’est pas entièrement déterminée par son 

nom, mais aussi par les types de ses arguments. 

Par exemple, operator +(...) ne fait pas ≪ la même 

chose ≫avec des entiers et des réels. 

Le programmeur peut redéfinir (surcharger) les opérateurs 

et les fonctions avec d’autres arguments. 

⇒fonctions membres d’une classe (constructeur, 

opérateurs arithmétiques, etc...). 

Le lien avec la ≪ bonne ≫fonction est fait par le 

compilateur.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Membres constants 

Les données membres constantes suivent les mêmes 

règles que les ≪ variables constantes ≫(elles sont 

initialisées dans les en-têtes). 

Une fonction membre constante (par exemple de 

Alpha) se déclare : 

double fonction1(const int&) const ; 

c’est une fonction qui ne modifie pas le données 

membres de la classe. 

Les fonctions membres constantes sont les seules à 

pouvoir être appelées sur des objets (de la classe 

Alpha, dans notre exemple) constants.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Données membres mutables 

La notion de constance peut correspondre à deux concepts 

différents : 

constance physique : l’objet conserve sa valeur initiale 

jusqu’à sa destruction (⇒const), 

constance logique : les utilisateurs perçoivent l’objet 

invariable (⇒donnée membre mutable). 

Les membres déclarés mutables peuvent être modifiés par 

toute fonction membre, constante ou non.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

TP n o 3 

une classe de stockage de réels 

Objectifs : 

Concevoir une classe de ≪ bas niveau ≫pour représenter 

des tableaux de réels à 1,2 ou 3 dimensions, avec l’espace 

mémoire alloué de manière dynamique. 

Cette classe pourra ensuite être utilisée pour stocker les 

coordonnées des points des grilles numériques, les valeurs 

des champs physiques en ces points, ... 

Elle fera les vérifications pour en lecture/écriture, afin 

d’éviter les dépassements de tableaux ; 

Elle possédera une arithmétiques complète et sera définie 

pour la plupart des fonctions mathématiques usuelles (sin, 

exp, √ , ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Programme principal 




#include "tab.h" 

int main() { 

Tab tab3d(2, 3, 4) ; 

tab3d = M_PI ; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Héritage et polymorphisme 

1 Héritage simple 

2 Héritage multiple 

3 Polymorphisme 

4 Exemples : les classes Etoile et Eos 

5 TP n o 4 : une classe de matrices

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


L’héritage permet d’utiliser les propriétés (données et fonctions 

membres) d’une classe existante en les enrichissant pour faire 

une nouvelle classe. 

class A ; 

class B : public A { ... } ; 

B (classe dérivée) est une sorte de A (classe de base). 

Les constructeurs, constructeur par copie, opérateurs 

d’affectation (tous) et destructeurs ne sont pas hérités. Il faut 

créer un constructeur avec une liste d’initialisation (en-tête) : 

B::B(...):A(...), données membres de B(...),... 

{ ... } ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


L’héritage permet d’utiliser les propriétés (données et fonctions 

membres) d’une classe existante en les enrichissant pour faire 

une nouvelle classe. 

class A ; 

class B : public A { ... } ; 

B (classe dérivée) est une sorte de A (classe de base). 

Les constructeurs, constructeur par copie, opérateurs 

d’affectation (tous) et destructeurs ne sont pas hérités. Il faut 

créer un constructeur avec une liste d’initialisation (en-tête) : 

B::B(...):A(...), données membres de B(...),... 

{ ... } ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Compatibilité implicite 

Par un héritage publique, une classe B dérivée de A offre les 

mêmes ≪ services ≫que A. Un objet de type B peut 

remplacer un objet de type A. 

Cela peut être utilisé avec des pointeurs ou des références : 

A a, *pa ; 

B b, *pb ; 

pa = &b ; // mais pas pb =&a ! ! 

Le type statique de pa est A *, le type 

dynamique de pa est B *.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Compatibilité implicite 

Par un héritage publique, une classe B dérivée de A offre les 

mêmes ≪ services ≫que A. Un objet de type B peut 

remplacer un objet de type A. 

Cela peut être utilisé avec des pointeurs ou des références : 

A a, *pa ; 

B b, *pb ; 

pa = &b ; // mais pas pb =&a ! ! 

Le type statique de pa est A *, le type 

dynamique de pa est B *.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Types d’héritage 

Dans l’exemple précédent, B hérite de façon publique de la 

classe A. Il est possible de décider du type d’héritage à 

l’aide de l’un des mots-clés : 

public : les membres hérités gardent les mêmes 

restrictions d’accès que dans la classe de base, 

protected : les membres hérités sont en accès 

protected, 

private : les membres hérités sont en accès private. 

SAUF les membres privés de la classe de base qui ne sont 

jamais accessibles dans les classes dérivées (mêmes pas par 

les fonctions membres !).

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Ajustement d’accès 

Lors d’un héritage protégé ou privé on peut décider que 

certains membres de la classe de base conservent leur type 

d’accès dans la classe dérivée. 

On ne peut en aucun cas augmenter ou diminuer les droits 

d’accès à un membre de la classe de base. 

class X { 

public: void f1() ; void f2() ; 

protected: void f3() ; void f4() ; }; 

class Y : private X { 

public: X::f1 ; //mais pas f3! 

protected: X::f4 ; //f2 et f3 sont privés dans 

Y 

};

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Classes et fonctions amies 

Les classes amies de la classes de base restent 

amies des membres hérités, mais pas des 

nouveaux membres des classes dérivées. 

Les fonctions amies de la classe de base ne le 

sont plus du tout (même pas pour les 

membres hérités) pour la classe dérivée ; il 

faut redéfinir les relations d’amitié avec les 

fonctions.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Héritage multiple 

Il permet de créer des classes dérivées utilisant 

plusieurs classes de bases. 

class A ; 

class B ; 

class C: public B, protected A { ... } ; 

Les constructeurs sont appelés dans l’ordre de 

déclaration de l’héritage (celui de B, puis de A, puis de 

la classe dérivée). 

Les destructeurs sont appelés dans l’ordre inverse de 

celui des constructeurs.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Héritage virtuel 

class A { ...} ; 

class B: public A { ...} ; 

class C: public A { ... } ; 

class D: public B, public C { ... } ; 

D contiendra deux fois les données héritées de A... 

Pour lever l’ambiguïté, il faut utiliser l’héritage virtuel : 

class B: virtual public A { ... } ; 

class C: virtual public A { ... } ; 


Cet héritage ≪ virtual ≫ne doit pas être confondu avec les 

membres virtuels du polymorphisme.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Héritage virtuel 

class A { ...} ; 

class B: public A { ...} ; 

class C: public A { ... } ; 


D contiendra deux fois les données héritées de A... 

Pour lever l’ambiguïté, il faut utiliser l’héritage virtuel : 

class B: virtual public A { ... } ; 

class C: virtual public A { ... } ; 


Cet héritage ≪ virtual ≫ne doit pas être confondu avec les 

membres virtuels du polymorphisme.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Polymorphisme 

L’idée de l’héritage (surtout public) est que si B hérite de A, B 

est une sorte de A. Il se peut néanmoins, que l’on ait envie de 

redéfinir (ou surcharger) dans B certains membres de A. 

B::affiche() ; 

A::affiche() ; différente 

B b ; 

A *ptr=&b ; 

ptr->affiche(); ? ? Au moment de la compilation, il est 

impossible de savoir quelle fonction appeler.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Liaison dynamique 

La liaison avec la ≪ bonne ≫fonction membre se fait au 

moment de l’exécution. Ce mécanisme se met en place dans la 

classe de base : class A { 

public: 

virtual void affiche() { ... } ; 

...} 

puis, dans la classe dérivée, il faut déclarer la même fonction 

membre, avec les mêmes arguments : 

class B: public A { 

public: virtual void affiche() { ... } ; 

...} .

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Fonctions membres virtuelles pures 

Certaines fonctions virtuelles sont trop générales pour pouvoir 

être définies (par exemple, dans la classe Eos). Mais elles sont 

quand même nécessaires... 

On peut définir ces fonctions pour qu’elles renvoient 

simplement un message d’erreur. Une meilleure solution est de 

les déclarer virtuelles pures : 

class A { 

public: 

virtual void affiche()=0 ; } 

Cela signifie que la définition de affiche() est différée et 

déléguée aux classes dérivées.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Classes abstraites 

Une classe abstraite est une classe qui ne peut pas être 

instanciée. 

C’est en général une classe dont l’implémentation est 

insuffisante pour représenter complètement un objet réel. Le 

rôle de la classe est de servir de ≪ moule ≫pour dériver d’autres 

classes. 

On peut avoir des classes abstraites 

si tous les constructeurs sont protégés ou privés, 

si la classe déclare au moins une fonction virtuelle pure, 

si la classe hérite d’une fonction virtuelle pure qu’elle ne 

définit pas. 

Si A est une classe abstraite, 

A a ; est illégal 

A *pta ; est permis.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Classes abstraites 

Une classe abstraite est une classe qui ne peut pas être 

instanciée. 

C’est en général une classe dont l’implémentation est 

insuffisante pour représenter complètement un objet réel. Le 

rôle de la classe est de servir de ≪ moule ≫pour dériver d’autres 

classes. 

On peut avoir des classes abstraites 

si tous les constructeurs sont protégés ou privés, 

si la classe déclare au moins une fonction virtuelle pure, 

si la classe hérite d’une fonction virtuelle pure qu’elle ne 

définit pas. 

Si A est une classe abstraite, 

A a ; est illégal 

A *pta ; est permis.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Exemples : 

les classes Etoile et Eos 

Etoile −→ Etoile rot −→ Et rot bifluid 

Eos(classe abstraite) −→ Eos poly, Eos tabul, 

...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

TP n o 4 : 

des matrices héritées de la classe de tableaux 

Objectifs : 

Concevoir une classe de matrices carrées héritant de la 

classe de tableaux (Tab) du TP n o 3. 

Cette classe pourra ensuite être utilisée pour décrire des 

opérateurs différentiels ou autres ... 

Elle aura des méthodes determinant(), Tab 

resout(const Tab&) et Matrice inverse() 

éventuellement virtuelles (possibilité de classes dérivées de 

Matrice (matrices triangulaires, à bandes, ...) qui seront 

définies plus tard 

Elle devra posséder un produit matriciel s’écrivant m1 * 

m2 ou mat * vec avec vec un Tab à une dimension 

Note : les méthodes Mat::resout(...), 

Mat::inverse(...), Mat::determinant(...) ne seront 

définies qu’après le cours sur le liens avec le fortran.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Programme principal 



#include "matrice.h" 

int main() { 

Tab rhs("memb_droite.dat") ; 

Matrice mat("matrice.dat") ; 

double max_rhs = max(abs(rhs)) ; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Quelques conseils pratiques ... 

1 Utilisation des références 

2 Entrées / sorties avec les fichiers 

3 Le mot-clef const 

4 Conception de classes

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Utilisation des références 

Rappel : Une valeur de type référence (type &) est une 

adresse, MAIS les modifications sur cette adresse touchent 

l’objet référencé et non l’adresse (qui ne peut être modifiée). 

De plus : 

le type void & n’est pas valide. 

il est impossible de créer un pointeur sur une référence 

(mais une référence sur un pointeur, si !), 

de créer une référence sur une référence, 

de créer un tableau de références. 

une référence doit toujours être définie (initialisée).

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Valeur, adresse, ou référence ? 

int a est un argument de fonction void f(...). 

Si la valeur de a doit aussi être retournée par f (de la 

fonction appelée à la fonction appelante), il faut passer a 

par adresse (pointeur ou référence) : 

void f(int *a) ; ou 

void f(int &a) ;. 

Sinon, et si la taille de a n’est pas plus grande que celle 

d’un entier, on peut passer a par valeur : void f(int 

a) ;. 

Ce second point vaut éventuellement pour les valeurs de retour 

de fonctions : si le type est ≪ petit ≫(recopie aussi rapide 

qu’une adresse) il vaut mieux retourner une valeur. Si, au 

contraire, il est ≪ gros ≫il vaut mieux retourner son adresse, 

mais attention aux référence !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Piège des renvois de références 

Ne jamais renvoyer une référence sur un objet détruit à la fin 

de la fonction appelée : 

Tab &operator+(Tab &t1, Tab &t2) { 

Tab resu(t1) ; 

... 

return resu ; }// ! ! ! 

Ne pas modifier l’objet référencé tant que la référence est 

utilisée : 

class pile { 

public: int &Top() ;// consulte/modifie le sommet 

int Pop() ;} ; // renvoie la valeur au sommet de la pile et 

l’enlève de la pile. Le problème apparaît pour : 

pile p; 

p.Top() = p.Pop()+1 ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Entrées / Sorties 

Rappel : les fonctions du C marchent aussi en C++ ! ! 

(printf, scanf...). 

Il existe 4 flux pré-définis, déclarés dans : 

cin, qui correspond à l’entrée standard (stdin en C), 

cout, qui correspond à la sortie standard (stdout en C), 

cerr, qui correspond à la sortie d’erreur (stderr en C), 

clog, qui est le flux de sortie d’≪ erreur tamponnée ≫. 

cout y ; 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Flux associés aux fichiers 

Il y a deux classes pré-définies dans pour gérer les 

entrées/sorties avec les fichiers : 

class ifstream pour les entrées, 

class ofstream pour les sorties. 

Exemple : 

ifstream f("entree.dat") ; 

ofstream g("sortie.dat") ; 

int n ; 

f >> n ; 

g

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Méthodes communes aux flux 

Ces méthodes peuvent être utilisées pour les 

entrées/sorties standards, comme pour les fichiers : 

>, qui sont surchargés pour les types standards, 

put(char c) et write(const char *s, int n) en 

écriture, 

get(char c), read(char *s, int n), 

getline(char *s, int, char delim=’\n’) et 

ignore(int n=1, int delim=EOF) en lecture.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Manipulateurs 

Ils sont équivalents aux fonctions membres des flux pour le 

formattage de l’information, mais leur appel est plus simple : 

dec, hex,... et setbase(int n) (sortie), 

endl, ends et flush (sortie), 

setfill(char c), setw(int n), setprecision(int 

n), fixed, scientific, left, right, 

uppercase,... (sortie), 

skipws, noskipws, ws (entrée), 

tab, decindent, incindent... (sortie).

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Manipulateurs 

exemple d’utilisation 

Comparez : 

cout.width(10) ; 

cout.fill(’*’) ; 

cout.setf(ios::hex, ios::basefield); 

cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

La classe string 

En C++, il existe une classe string, pour manipuler les 

chaînes de caractères (#include). 

constructeurs : string chaine ; string suite = 

"bonjour" ; 

accès : chaine.size() ; chaine.length() ; 

suite[i] ; ... 

manipulation : chaine += suite ; string total = 

chaine + suite ; ... 

comparaison : chaine.compare(suite) ; 

récupération du char* : chaine.c str() ; 

chaine.data() ; (sans le ’\0’) 

autres : find, copy, ... 

Certaines de ces fonctions sont surchargées, avec des 

arguments supplémentaires permettant de travailler sur une 

partie de la chaîne de caractères.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Flux d’entrée/sortie 

un exemple complet 







int main() { 

double mass_b = -1 ; 

double e1, e2, om1, om2, press, ener, mg, mb1, mb2 ; 

for (int i=1; i om2 >> press >> ener >> mg >> mb1 >> mb2 ; 

} 

} 

return EXIT_SUCCESS ; 

}

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Utilisation de const 

Quand faut-il déclarer un argument de fonction constant ? 

Dès que la fonction n’a besoin que de ≪ lire ≫la valeur de 

cet argument (elle ne le retourne pas...) ⇒sans objet pour 

les valeurs. 

Si une classe n’a aucune fonction membre prenant des 

constantes, il sera difficile d’instancier des objets constants 

de cette classe. 

⇒Le constructeur par recopie et l’opérateur d’affectation 

doivent prendre des arguments const. 

Quand une fonction prends des objets const, elle peut aussi 

prendre des non-const !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Quand faut-il déclarer un argument de fonction constant ? 

Dès que la fonction n’a besoin que de ≪ lire ≫la valeur de 

cet argument (elle ne le retourne pas...) ⇒sans objet pour 

les valeurs. 

Si une classe n’a aucune fonction membre prenant des 

constantes, il sera difficile d’instancier des objets constants 

de cette classe. 

⇒Le constructeur par recopie et l’opérateur d’affectation 

doivent prendre des arguments const. 

Quand une fonction prends des objets const, elle peut aussi 

prendre des non-const !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Quand une fonction membre doit-elle être constante ? 

Les fonctions membres constantes ne modifient pas les 

données de la classe sur laquelle elles sont appelées. 

Il faut faire appel au maximum à celles-ci, en faisant 

attention qu’elles soient vraiment ≪ constantes ≫. 

Éventuellement, on peut déclarer des données mutable. 

Renvoi de constante par une fonction membre ? 

Dès que la fonction membre renvoie une référence 

(attention !) ou un pointeur sur une donnée membre 

constante !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Quand une fonction membre doit-elle être constante ? 

Les fonctions membres constantes ne modifient pas les 

données de la classe sur laquelle elles sont appelées. 

Il faut faire appel au maximum à celles-ci, en faisant 

attention qu’elles soient vraiment ≪ constantes ≫. 

Éventuellement, on peut déclarer des données mutable. 

Renvoi de constante par une fonction membre ? 

Dès que la fonction membre renvoie une référence 

(attention !) ou un pointeur sur une donnée membre 

constante !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Conception de classes 

Optique de la programmation par objets 

encapsulation : regrouper dans une même classe les 

structures de données (les données membres) et les 

fonctions qui les manipulent. 

abstraction de données : Bien séparer une partie privée 

et une partie publique. La partie privée contient les 

structures de données et les fonctions à usage interne. La 

partie publique contient les fonctions et variables offertes 

aux utilisateurs de la classe. 

On appelle interface de la classe ce qui est accessible par tout le 

monde et implémentation ce qui ne l’est que par le concepteur.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Les constructeurs 

Pour tous les constructeurs (y compris les constructeurs 

par recopie), privilégier la liste d’initialisation à la recopie 

dans le corps de la méthode. 

Définir un constructeur pour les classes dérivées : en effet, 

si la classe de base a un constructeur déclaré, la classe 

dérivée n’a pas de constructeur par défaut (synthétisé). 

Si, parmi les données membres de la classe, il y a une 

constante ou une référence, il n’y a pas de constructeur 

par défaut synthétisé par le compilateur. 

⇒toujours déclarer au moins un constructeur, même s’il ne fait 

rien !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


operator=, constructeur par recopie et destructeur 

Un destructeur ne fait rien, sauf si la classe contient des 

objets alloués dynamiquement. 

Il peut être utile de déclarer le destructeur virtual, que 

la classe fasse appel à l’héritage ou non. 

nécessité du constructeur par recopie 

A chaque appel d’une fonction ayant pour argument un 

membre de la classe, il y a duplication de cet argument. 

Le constructeur par recopie ≪ synthétisé ≫ne copie pas les 

tableaux dynamiques, ni les objets externes à la classe (par 

ex : les FILE *). 


Il ne crée pas l’objet, mais ne fait que copier ses membres. 

Comme l’objet existe déjà, il doit le ≪ nettoyer ≫ou vérifier 

qu’il est compatible ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

















Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

















Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Affichage 

Parmi les fonctions membres, en plus des 4 fortement 

conseillées, il est souvent très commode de définir un opérateur 

d’affichage : 

(friend) ostream& operator

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Pour aller plus loin 

1 C++ et fortran 

2 Espaces de noms 

3 Variables statiques 

4 Conversion de types 

5 Pointeurs de fonctions 

6 Modèles de fonctions et de classes 

7 Bibliothèques prédéfinies

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Mélanger C++ et fortran 

Appeler du fortran depuis le C++ 

Il est possible d’appeler des fonctions (ou sous-routines) 

fortran (66, 77, 95, 2003 ?) depuis un programme en C++ : 

Du côté C++, la fonction fortran doit être déclarée 

avec, éventuellement, un ou deux ≪ ≫à la fin de son nom. 

Le fortran ne travaille qu’avec des pointeurs, il faut 

donc passer toutes les variables par adresse. 

On ne peut passer que des types simples (int, float, 

double et char), surtout pas de classe ! ! 

Il faut compiler chaque fichier (.cpp ou .f) avec son 

compilateur et, pour le lien, utiliser le compilateur C++ 

(le programme principal est en C++ !) avec la bonne 

bibliothèque ( ex : g++ -o prog cmain.o fonc.o 

-lg2c ou -lgfortran pour les compilateurs GNU)

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Programme principal C++ 





extern "C" { 

void fonction_for_(double* , int* ) ; 

} 

int main() { 

cout n ; 

double* tab = new double[n] ; 

for (int i=0; i

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Fonction fortran 

subroutine fonction_for(tab, n) 

implicit none 

integer n, i 

double precision tab(n) 

do i=1, n 

write(*,*) ’tab[’,i,’]=’,tab(i) 

enddo 

return 

end

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Mélanger C++ et fortran 

Appeler du C++ depuis le fortran 

il faut faire une fonction ≪ chapeau ≫en C, déclarée 

comme externe, qui appelle la fonction C++ 

comme pour le cas inverse, il ne faut passer que des 

adresses de types simples 

dans la routine fortran, il faut faire appel à la fonction 

chapeau 

chaque fichier est compilé dans le langage idoine, le lien se 

faisant avec le compilateur fortran (programme 

principal !) en ajoutant la bibliothèque standard du C++ : 

par ex. pour les compilateurs GNU ≪ gfortran -o prog 

fmain.o fonc.o -lstdc++ ≫

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Programme principal fortran 

program ftest 

implicit none 

integer n, i 

parameter (n=10) 

double precision a(n) 

do i=1,n 

a(i)=sqrt(dble(3+i)) 

enddo 

call fonction_c(a,n) 

end

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Fonction C++ 


using namespace std; 

void fonction_cpp (double* a, const int* n) 

{ for (int m=0; m

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

TP n o 5 : 

appels à la bibliothèque LAPACK pour les matrices 

bibliothèque numérique pour les problèmes d’algèbre 

linéaire, écrite en fortran (Cf. 

http://www.netlib.org/lapack ) 

Utiliser les page man pour connaître les arguments des 

routines dgetrf (factorisation LU), dgetrs (résolution de 

système), dgetri (inversion de matrice) et dgeev (calcul 

de valeurs propres). 

implémenter l’appel aux routines de solutions d’équations 

linéaires, d’inversion et de calcul de valeurs propres (pour 

le déterminant) pour faire fonctionner la classe Matrice 

tester sur des systèmes simples... et faire tourner le 

programme principal du TP n o 4.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Appel à LAPACK 

fonction de factorisation dgetrf 

DGETRF(l) ) DGETRF(l) 

NAME 

DGETRF - compute an LU factorization of a general M-by-N matrix A using partial 

pivoting with row interchanges 

SYNOPSIS 

SUBROUTINE DGETRF( M, N, A, LDA, IPIV, INFO ) 

INTEGER INFO, LDA, M, N 

INTEGER IPIV( * ) 

DOUBLE PRECISION A( LDA, * ) 

PURPOSE 

DGETRF computes an LU factorization of a general M-by-N matrix A using partial 

pivoting with row interchanges. The factorization has the form 

A = P * L * U 

where P is a permutation matrix, L is lower triangular with unit diagonal elements 

(lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal 

if m < n). 

This is the right-looking Level 3 BLAS version of the algorithm. 

LAPACK version 3.0 15 June 2000 DGETRF(l)

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Appel à LAPACK 

fonction de factorisation dgetrf 

ARGUMENTS 

M (input) INTEGER 

The number of rows of the matrix A. M >= 0. 

N (input) INTEGER 

The number of columns of the matrix A. N >= 0. 

A (input/output) DOUBLE PRECISION array, dimension (LDA,N) 

On entry, the M-by-N matrix to be factored. On exit, the factors L and 

U from the factorization A = P*L*U; the unit diagonal elements of L are 

not stored. 

LDA (input) INTEGER 

The leading dimension of the array A. LDA >= max(1,M). 

IPIV (output) INTEGER array, dimension (min(M,N)) 

The pivot indices; for 1

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Espaces de noms 

Lors de l’utilisation combinée de bibliothèques de fonctions, il 

peut y avoir conflit entre des noms (identificateurs). Les 

espaces de noms permettent de régler ce type de problèmes. 

namespace N { 

int i,j ; 

void f() { ... } 

class C { ... } ; } 

L’appel dans le programme principal se fait alors avec : 

N::f() ; Les identificateurs déclarés dans un espace de noms 

sont appelés membres de l’espace. Ce qui différencie les espaces 

de noms des autres régions déclaratives (blocs, structures, 

classes) c’est leur possibilité d’être définis ≪ par morceaux ≫.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Espaces de noms 

l’instruction using 

La déclaration : 

using N::C ; introduit la classe N::C dans la région 

courante. 

using N::C ; 

C c ; //c’est-à-dire N::C 

La directive : 

using namespace N ; introduit tous les identificateurs de 

N dans la région courante. Tous les objets déclarés dans N 

peuvent alors être utilisés sans l’opérateur de résolution de 

portée (::). 

Attention aux déclarations multiples de variables (non 

constantes), si l’espace de nom est inclus dans différents 

fichiers sources. ⇒utiliser le mot-clef ≪ extern ≫.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Variables statiques 

Une variable déclarée static est valable jusqu’à la fin de 

l’exécution. 

Cela peut être une façon déguisée de passer des arguments 

à une fonction, 

ou une aide pour ne pas avoir à réévaluer certains objets 

ou allouer des tableaux. 

Attention aux programmes parallélisés ! 

Les variables statiques ≪ simples ≫sont en voie de disparition 

en C++. On peut utiliser à leur place les espaces de noms. 

Elles restent intéressantes comme membres de classe.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Variables statiques 

Une variable déclarée static est valable jusqu’à la fin de 

l’exécution. 

Cela peut être une façon déguisée de passer des arguments 

à une fonction, 

ou une aide pour ne pas avoir à réévaluer certains objets 

ou allouer des tableaux. 

Attention aux programmes parallélisés ! 

Les variables statiques ≪ simples ≫sont en voie de disparition 

en C++. On peut utiliser à leur place les espaces de noms. 

Elles restent intéressantes comme membres de classe.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Espaces anonymes 

Il s’agit d’un espace de noms ... sans nom ! 

namespace 

{ 

int nombre d appels = 0 ; 

void affiche n appels() { cout ... } 

} 

Le nom est attribué par le compilateur et dépend du fichier. En 

plus, la directive using avec ce nom est insérée après sa 

définition. 

⇒C’est une façon alternative d’écrire : 

static int nombre d appels = 0 ; ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Espaces anonymes 

Il s’agit d’un espace de noms ... sans nom ! 

namespace 

{ 

int nombre d appels = 0 ; 

void affiche n appels() { cout ... } 

} 

Le nom est attribué par le compilateur et dépend du fichier. En 

plus, la directive using avec ce nom est insérée après sa 

définition. 

⇒C’est une façon alternative d’écrire : 

static int nombre d appels = 0 ; ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Membres statiques 

Données membres statiques : 

Les données membres statiques sont partagées par toutes les 

instances de la classe. 

class Alpha { 

static double se ;... } ; 

Puis, dans le programme principal (ou appelant), on peut 

définir sa valeur, avant toute instance : 

Alpha::se = 6.67 

Alpha a; 

double y = a.se/2. ; 

ou encore : double y = Alpha::se/2 ; 

Fonctions membres statiques : 

Elles ont les mêmes propriétés que les données membres. Les 

fonctions membres statiques publiques peuvent donc être 

utilisées indépendamment de tout objet.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Conversion de types 

Toute règle a besoin d’exception... 

Une conversion entre deux types de variables peut se faire 

de manière implicite ou explicite : 

int i ; 

double x = i ; // c’est implicite 

double y = double(i) ; // c’est explicite 

double z = (double) i ; // aussi explicite, et ça 

marche avec les pointeurs... 

Quelle que soit la manière d’écrire la conversion, il faut que 

la fonction qui effectue la conversion existe quelque part !

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Constructeurs à un paramètre 

C’est un constructeur d’une classe qui peut être appelé 

avec un seul argument (il prend un seul argument ou 

un seul argument sans valeur par défaut). 

Sans mention contraire (explicit), il peut être utilisé 

pour faire une conversion implicite : 

explicit Tab(int size0) ; 

Sinon, c’est un constructeur de conversion, qui permet 

de passer du type int au type Tab. L’inverse est 

impossible avec un constructeur, il faut définir un 

opérateur de conversion.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Opérateurs de conversion de type 

Il est possible de définir une fonction membre : 

A::operator B() 

qui définit une conversion de A vers B. 

Cet opérateur peut être utilisé par le compilateur pour 

effectuer des conversions implicites. Pour éviter cela, il faut 

utiliser le mot-clef explicit : 

class Z { 

public: 

explicit operator int() ; 

} ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Conversions de types 

Conversions implicites 

Lors d’une conversion implicite, le compilateur doit choisir une 

série de conversions parmi les ≪ standards ≫du langage et celles 

définies par l’utilisateur. Les standards sont : 

les changements entre const et non-const, 

les changements entre entiers (char, short, int, 

long, unsigned...) ou booléens, 

les changements entre float et double, 

les conversions entre entiers et réels, 

certaines conversions entre pointeurs (de type (type *) 

vers (void *), entre pointeurs sur la classe dérivée et sur 

la classe de base), 

entre tableaux et pointeurs d’un même type. 

Une séquence de conversions implicites ne peut contenir plus 

d’une conversion définie par l’utilisateur.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

















Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

















Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Résolution des surcharges 

La résolution des surcharges est un algorithme complexe, qui se 

déroule en trois phases : 

détermination des fonctions candidates (nom), 

détermination des fonctions viables (arguments), 

détermination de la meilleure fonction viable (le 

≪ moins ≫de conversions). 

La deuxième étape recherche les fonctions dont les arguments 

sont compatibles, après conversions implicites, avec la liste du 

programme. 

Le compilateur ne donne aucun avertissement sur les 

conversions qu’il a utilisées, ce qui peut donner des résultats 

incompréhensibles ou des ambiguïtés. 

⇒il faut définir un maximum de constructeurs et opérateurs de 

conversion explicites.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Résolution des surcharges 

La résolution des surcharges est un algorithme complexe, qui se 

déroule en trois phases : 

détermination des fonctions candidates (nom), 

détermination des fonctions viables (arguments), 

détermination de la meilleure fonction viable (le 

≪ moins ≫de conversions). 

La deuxième étape recherche les fonctions dont les arguments 

sont compatibles, après conversions implicites, avec la liste du 

programme. 

Le compilateur ne donne aucun avertissement sur les 

conversions qu’il a utilisées, ce qui peut donner des résultats 

incompréhensibles ou des ambiguïtés. 

⇒il faut définir un maximum de constructeurs et opérateurs de 

conversion explicites.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


La famille de cast 

L’opération de cast marche en C++, mais est à éviter (aucun 

contrôle). Il existe 4 opérateurs de conversion plus explicites : 

reinterpret cast(type depart), 

pour les conversions mal définies (envoie une suite de bits 

sans interprétation). 

static cast(type depart), pour 

les conversions bien définies (mais pas des const). 

const cast(type depart), pour 

enlever ou ajouter l’attribut const à un type. 

dynamic cast(p), T est un type pointeur et p un 

pointeur vers un type polymorphe. p est converti en T si le 

type dynamique de *p est T ou un type dont T est une 

classe de base. S’il y a échec le résultat est 0x0.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Pointeurs de fonctions 

On ne peut faire que deux choses avec une fonction : 

l’appeler et prendre son adresse. Le pointeur obtenu en 

prenant l’adresse d’une fonction peut être ensuite utilisé 

pour appeler cette fonction : 

void error(char *p) { ... } 

void (*efct)(char*) ; //pointeur de fonction 

efct = &error ;//’efct’ pointe vers ’error’ 

(*efct)("error") ;//appel 

Il peut aussi être utile d’avoir des tableaux de pointeurs de 

fonctions.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Pointeurs de fonctions 

On ne peut faire que deux choses avec une fonction : 

l’appeler et prendre son adresse. Le pointeur obtenu en 

prenant l’adresse d’une fonction peut être ensuite utilisé 

pour appeler cette fonction : 

void error(char *p) { ... } 

void (*efct)(char*) ; //pointeur de fonction 

efct = &error ;//’efct’ pointe vers ’error’ 

(*efct)("error") ;//appel 

Il peut aussi être utile d’avoir des tableaux de pointeurs de 

fonctions.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Modèles 

Fonctions 

D’une manière générale, ce sont des canevas décrivant une 

famille de composants : famille de fonctions, famille de types, 

famille de membres, ... 

Ils sont définis à l’aide du mot-clef template. 

Dans le cas des fonctions, on déclare : 

template 

void f() { 

float tab[N] ; 

for (int i=0; i> tab[i] ; ... 

} 

Puis, dans le programme principal : 

const int n = 128 ; 

f() ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Modèles 

Fonctions 

D’une manière générale, ce sont des canevas décrivant une 

famille de composants : famille de fonctions, famille de types, 

famille de membres, ... 

Ils sont définis à l’aide du mot-clef template. 

Dans le cas des fonctions, on déclare : 

template 

void f() { 

float tab[N] ; 

for (int i=0; i> tab[i] ; ... 

} 

Puis, dans le programme principal : 

const int n = 128 ; 

f() ;

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Modèles 

Classes 

template 

class Tab { 

double tab[B-A+1] ; 

public: 

double &operator[](int i) { 

assert(i>=A && i

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Modèles 

Paramètres-types 

En général, les paramètres de modèles sont de type 

arithmétiques (valeur, pointeur ou référence) et ne 

peuvent être modifiés. 

On peut néanmoins donner comme paramètre un type : 

template 

void swap(C &a, C &b) { ... } 

ou à l’aide du mot-clef typename : 

template 

void swap(C &a, C &b) { ... } 

Puis, à l’appel :swap(i1,i2) ; 

ou swap(x1,x2); 

Cela s’applique de la même façon aux modèles de classes. Ces 

deux genres de paramètres peuvent se combiner avec, 

éventuellement, des valeurs par défaut.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Modèles 

Compilation des modèles avec paramètres-types 

Un modèle (fonction ou classe) avec un 

paramètre-type ne peut pas être compilé si le 

type n’est pas spécifié. 

Il faut donc traiter les définitions comme des 

déclarations et les inclure dans les 

programmes utilisant ces modèles (pas de lien 

par le compilateur). 

La compilation du modèle (classe ou 

fonction) se fera à chaque instance ou appel.

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

Bibliothèques pré-définies 

Gestion des entrées / sorties 

Les bibliothèques d’entrées/sorties et l’espace de 

nom std (cela peut dépendre de l’âge du compilateur) : 

ios 

istream 

ostream 

iostream 

ifstream 

fstream 

fstreambase ofstream

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Modes d’ouverture des flots 

La déclaration du constructeur de ofstream à partir d’un nom 

(de fichier) est, en fait, la suivante : 

explicit ofstream::ofstream(const char *name, 

ios base::openmode 

mode=ios base::out|ios base::trunc) ; 

app : en mode ajout à la fin 

ate : positionné à la fin 

in : en mode lecture 

out : en mode écriture 

binary : en mode binaire 

trunc : efface le contenu à l’ouverture

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 


Gestion des exceptions 

Une possibilité est d’utiliser les assert. Mais il existe une 

gestion très complète qui est, pour partie, définie dans 

et fait appel aux trois instructions 

throw/try/catch. 

void g(const char *name) { 

FILE *f ; 

f = fopen(name,"r") ; 

if (f==NULL) throw 1 ; } , et, dans une fonction 

appelante ∗ : 

try { 

g(name) ; } 

catch(int n) { 

if (n==1) cout

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 



S’il n’y a aucun catch avec le bon argument pour 

rattraper l’expression lancée par throw, alors le programme 

est arrêté. 

Un bloc try peut être suivi de plusieurs gestionnaires 

catch : 

catch(int) { ... } 

catch(char *msg) { ... } 

catch(...) { ... } 

return 0 ; 

Le premier qui a un argument compatible sera exécuté, 

puis le programme continuera après le dernier catch. 

La présence d’une instruction throw; dans un gestionnaire 

indique que l’exception doit continuer à remonter à travers 

la pile des appels (traitement partiel).

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 



Une fonction peut spécifier dans sa déclaration et sa définition 

les exceptions qu’elle est en mesure de lancer, directement ou 

par propagation : 

void g(int p) throw(char *) { ... } 

Lorsque rien n’est mentionné, la fonction peut lancer n’importe 

quel type d’exception. Si throw() est mentionné, aucune 

exception ne peut être lancée (attention à la remontée des 

appels !). 

Les bibliothèques , et 

contiennent un certain nombre de classes utilisées par le 

système et lancées par les opérateurs du langage : 

bad exception, bad alloc, bad cast, 

invalid argument, overflow error, ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 



Une fonction peut spécifier dans sa déclaration et sa définition 

les exceptions qu’elle est en mesure de lancer, directement ou 

par propagation : 

void g(int p) throw(char *) { ... } 

Lorsque rien n’est mentionné, la fonction peut lancer n’importe 

quel type d’exception. Si throw() est mentionné, aucune 

exception ne peut être lancée (attention à la remontée des 

appels !). 

Les bibliothèques , et 

contiennent un certain nombre de classes utilisées par le 

système et lancées par les opérateurs du langage : 

bad exception, bad alloc, bad cast, 

invalid argument, overflow error, ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

La Standard Template Library (STL) 

C’est une bibliothèque (présente dans /usr/.../include/g++/) 

qui permet d’utiliser des modèles standard, fréquemment 

utilisés par un certain nombre de programmeurs en C++. Par 

exemple, le modèle de classes vector : 

template 

class vector ; 

c’est un conteneur, qui se rapproche le plus des tableaux 

C++, 

il détecte quand on dépasse sa capacité et s’agrandit 

automatiquement, 

il dispose de fonctions membres size, erase, clear ou 

insert. 

Il est déclaré dans .

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

La Standard Template Library (STL) 

D’autres modèles existent : 

des utilitaires (dans et ), 

d’autres conteneurs (dans et ), 

des composants pour le calcul numérique (, 

), 

des itérateurs, algorithmes, ...

Le C++ 


Introduction 

Motivations 

Les cours 


Les classes 

Syntaxe 

Les types 

Les fonctions 


Pointeurs 


Constantes 

Les classes 

Les membres 

Accès 

Surcharges 

const 

Héritage 



Polymorphisme 

≪ En 

pratique ≫ 

Références 

C++0x 

Des nouveautés, pas de révolution, mais encore peu de 

compilateurs la prennent en compte : par ex. g++ -std=c++0x 

Appel à un autre constructeur depuis un constructeur de 

la meme classe 

boucles sur des tableaux 

type ≪ auto ≫. . .et decltype 

pointeur nul nullptr 

fonctions anonymes 

gestion du temps (bibliothèque ) 

. . .

Cours - LUTH - Observatoire de Paris

Create successful ePaper yourself

Delete template?

Save as template?