#include <iostream>

int main ()
{
  std::cout << "Bienvenue au "
               "cours du GULL "
               "sur C++ !\n";
}

TOC

1. C++

Historique

Design de C++

C++ :

• est un langage compilé généraliste ;
• conserve la compatibilité avec C :
  • C89 est pratiquement un sous-ensemble de C++ ;
• est compatible multi-plateforme ;
• est utilisable pour la programmation de systèmes :
  • avec maîtrise du degré de support runtime CPU et RAM nécessaire (seules les instructions new, delete, typeid, dynamic_cast et throw ont besoin de support) ;
  • mais tout le monde n'est pas d'accord… (cf. Linux) ;
• supporte la programmation procédurale (fonctions) ;
• supporte la programmation modulaire (compilation séparée, namespaces) ;
• supporte la programmation orientée objet (classes, héritage) :
  • C++ n'est pas un langage orienté objet, mais il supporte cette méthode de programmation ;
• supporte la programmation générique (templates) ;
• vérifie les types à la compilation (typage statique).

Utilisation

• La première moitié des années 1990, C++ était très en vogue en entreprise avec la programmation orientée objets :
  • classes, héritage (multiple), surcharge d'opérateur ;
  • peu de templates ;
  • pas d'exceptions ;
  • pas de bibliothèque standard hormi les streams ;
  • pas de namespace.
• Fin-1990, C++ perd du terrain face à Java pour le développement en entreprise.
• Début 2000, les compilateurs C++ commencent à bien supporter le standard, ce qui est excessivement difficile et reste un problème.
• C++ reste très utilisé pour les produits [*] :
  • Adobe Photoshop, Illustrator, Acrobat, InDesign, GoLive ;
  • KDE ;
  • Microsoft Office, Internet Explorer, Visual Studio, Exchange, SQL, FrontPage, tous les jeux ;
  • Mozilla ;
  • OpenOffice ;
  • Sun HotSpot Java Virtual Machine ;
  • Symbian OS ;
  • …

Mots clé de C++

Pas des mots clé de C++

Hello world : Aperçu de la syntaxe

#include <iostream>
int main ()
{
  std::cout << "Hello, new world!\n";
}

• Comme en C, Java, JavaScript, C# :
  • l'indentation est libre, avec des blocs d'instructions entre accolades { } ;
  • on utilise des parenthèses () pour les fonctions ;
  • on met les chaînes de caractères entre guillemets " " et échappe avec \.
• Comme en C :
  • les déclarations sont dans des fichiers d'en-tête inclus avec le préprocesseur ;
  • il y a des types de base, int, char, etc. ;
  • on déclare variables et fonctions ;
  • le programme commence par la fonction main ;
  • il existe des variables globales ;
  • il existe de nombreux opérateurs comme << ;
  • le point-virgule ; est obligatoire en fin d'instruction.
• En C++ :
  • il y a des namespaces, dont std ;
  • il existe quelques nouveaux opérateurs comme :: ;
  • on peut surcharger les opérateurs comme <<.

Hello world : évolution ARM - ISO C++

#include <iostream.h>
int main ()
{
  cout << "Hello, new world!\n";
  return 0;
}

#include <iostream>
using namespace std;

Types de base

bool b             = true;
char c             = 'A';
wchar_t wc         = L'A';
signed char sbyte  = -128;
unsigned char byte = 255;
short s            = 32767;
unsigned short us  = 22;
int i              = 32;
unsigned u         = 65535u;
long l             = 123456789L;
unsigned long ul   = 4294967295UL;
float f            = 1.23f;
double g           = 1324e-53;
long double h      = 1324e156L;
void F ();

• Ce sont les mêmes types qu'en C, sauf bool et wchar_t.
• On utilise surtout int et char.
• Le nombre de bits des types dépend de la plateforme.
• void signifie « rien », aucune valeur.

Définition d'objets (de variables)

int global; // définition d'un objet global de type int

void f ()   // définition d'une fonction globale
{
  int local;       // objet local non initialisé
  int local2 = 2;  // initialisé avec la syntaxe C
  int local3 (3);  // initialisé avec la syntaxe C++
  ObjetComplique obj("hello", 132, '0'); // syntaxe C++ avec
                                         // plusieurs paramètres
  int locale ();   // déclaration de fonction !
  local = 3;                 // instruction
  AutreObjet apres = local;  // définition après instruction
  for (int i = 0; i < 10; ++i) { /* ... */ }
  // destruction automatique des objets locaux
}

• En C/C++, « objet » est synonyme de « variable ».
• On peut définir des objets globaux (déconseillé) ou locaux à une fonction.
• Il n'y a pas de différence entre objets de type de base et autres objets.
• On peut définir des objets après les instructions, lorsqu'on dispose des données d'initialisation.
• On peut déclarer un objet dans le test de for, while ou if.
• Les objets locaux sont automatiquement détruits en sortant du bloc.

Modificateurs de stockage

#include <iostream>

int i = 10;  // définition de i
void f ();   // déclaration de f

int main () { f(); f(); }

void f () {  // définition de f
  extern int i;      // déclaration (définition ci-dessus)
  static int j = 0;  // objet statique, survit au bloc
  int k = 0;         // objet local
  const int c = 0;   // objet local constant
  std::cout<<++i<<' '<<++j<<' '<<++k<<' '<<++c<<'\n';
  std::cout<<++i<<' '<<++j<<' '<<++k<<' '<<++c<<".\n";
}

/tmp> ./a.out
11 1 1 0
12 2 2 0.
13 3 1 0
14 4 2 0.

• L'objet, la fonction, existe où il est défini. Une déclaration indique que l'objet, la fonction, existe mais est défini ailleurs.

Opérateurs

opérateurs de C/C++

., ->, [], (), ++, --, sizeof, ~, !, -, +, &, *, /, %, <<, >>, <, <=, >, >=, ==, !=, ^, |, &&, ||, =, *=, /=, %=, %=, +=, -=, <<=, >>=, &=, |=, ^=, ?:, ,

opérateurs de C++

::, typeid, dynamic_cast, static_cast, reinterpret_cast, const_cast, new, new[], delete, delete[], .*, ->*, throw

opérateurs surchargeables en C++

+, -, *, /, %, ^, &, |, ~, !, =, <, >, +=, -=, *=, /=, %=, ^=, &=, |=, <<, >>, >>=, <<=, ==, !=, <=, >=, &&, ||, ++, --, ->*, ,, ->, [], (), new, new[], delete, delete[]

Valeur, référence et pointeur

#include <iostream>
int main () {
  int   i = 1;   // valeur entière
  int & r0;      // une référence doit être initialisée
  int & r = i;   // référence à une valeur entière
  int * p0;      // pointeur non initialisé
  int * p = i;   // erreur, types incompatibles
  int * p = &i;  // pointeur sur une valeur entière
  std::cout<< i <<' '<< r <<' '<<  p <<'\n'
           << i <<' '<< r <<' '<< *p <<'\n';
  ++r;  // incrémente i à travers r
  ++p;  // incrémente p qui pointe à côté de i ! ++*p est OK.
  std::cout<< i <<' '<< r <<' '<<  p <<'\n'
           << i <<' '<< r <<' '<< *p <<'\n';
}

/tmp> ./a.out
1 1 0xbffff914
1 1 1
2 2 0xbffff918
2 2 -1073743544

• * pointeur : opérateur unaire préfixé de déréférencement (pointage)
• & variable : opérateur unaire préfixé d'adresse

Types définis

enum Couleur { BLANC, ROUGE = 0xF00, VERT = 0x0F0, BLEU };
Couleur c = VERT;  // défini une variable de type Couleur

struct Fraction {
  int numerateur;
  int diviseur;
};
Fraction f = { 1, 2 };  // défini une variable de type Fraction

int main () {
  f . numerateur = 2 ;    // accès au membre
  Fraction * pf = & f ;   // pointeur sur Fraction
  pf -> diviseur = 3 ;    // équivalent à (*pf).diviseur
  // pointeur sur membre de Fraction de type int
  int Fraction :: * pm = & Fraction :: numerateur ;
  f .* pm = 4 ;
  pf ->* pm = 5 ;
}

• Le nom du type suffit pour déclarer une variable, inutile de répéter struct comme en C.
• L'opérateur . permet d'accéder à un membre de structure.
• L'opérateur -> permet d'accéder à un membre de structure pointée.
• Les pointeurs sur membre et leur opérateurs .* et ->* sont rarement utilisés.

Passage de paramètres

#include <iostream>
void f1 (int   i) {  i = 1; } // par valeur
void f2 (int & i) {  i = 2; } // par référence
void f3 (int * i) { *i = 3; } // par pointeur
int main ()
{
  int i[] = { 0, 0, 0 };
               f1 (i[0]);  f2 (i[1]); f3 (&i[2]);
  std::cout<<"{ "<<i[0]<<", "<<i[1]<<", "<<i[2]<<" }\n";
  f1 (0);
  f2 (0);  // interdit
  f3 (0);  // pointeur nul, plante f3() !
}

/tmp> ./a.out
{ 0, 2, 3 }
Erreur de segmentation

• Le passage de paramètres est la principale utilisation des références.
• Dans d'autres langages, le passage par référence est le mode par défaut.
• Avantage sur les pointeurs : une référence ne peut pas être nulle.
• Les références permettent d'utiliser la même syntaxe qu'un passage par valeur, ça peut changer un objet de manière inattendue.

Allocation de mémoire : new et delete

#include <memory>
#include <string>
int * f () {
  int * pi1 = new int;  // simple allocation de mémoire
  int * pi2 = new int (2);  // initialise
  std::string * pi3 = new std::string("leak");  // construit
  std::auto_ptr<int> pi4 (new int(4));
  delete pi1;  // libère *pi1
  return pi2;  // *pi2 reste pointé par p dans main
  // *pi3 n'est plus pointé => mémoire perdue (fuite, leak)
  // *pi4 est détruit par le destructeur de pi4.
}
int main () {
  int * p = f ();
  delete p;
}

• C++ ne gère pas automatiquement la mémoire (pas de ramasse-miette).
• Tout objet construit par new survit jusqu'à destruction par un delete.
• malloc et free de C sont de plus bas niveau, ils ne font qu'allouer des bytes.
• L'usage de new dépend de la durée de vie de l'objet, pas de son type.
• Les smart pointer comme auto_ptr peuvent aider.

Compilation

/tmp> cat >hello.cc
#include <iostream>

int main ()
{
  std::cout << "Hello, new world!\n";
}
/tmp> g++ hello.cc
/tmp> ls -l a.out
-rwxrwxr-x  1 marc marc 13527 2006-01-12 23:52 a.out
/tmp> ./a.out
Hello, new world!
/tmp> 

• hello.cc : fichier C++ en entrée
• Extensions communes de fichiers C++ : .cc, .cpp, .cxx, .C, .c++
• G++ fait partie de GNU Compiler Collection (GCC)
• Compilateurs gratuits : Visual C++ Express, Intel C++, etc.
• La conformance au standard ISO C++ varie !
• a.out : exécutable en langage machine en sortie

Erreurs de compilation

#include <iostream>

int main ()
{
  std::cout << "Hello, new world!\n"
}

/tmp> g++ hello.cc
hello.cc: In function `int main()':
hello.cc:6: erreur: expected `;' avant un élément lexical « } »
/tmp> 

int main ()
{
  std::cout << "Hello, new world!\n";
}

/tmp> g++ hello.cc
hello.cc: In function `int main()':
hello.cc:3: erreur: « cout » n'est pas un membre de « std »
/tmp> 

/tmp> gcc hello.cc
/tmp/ccsbrTRT.o(.text+0xd): In function `std::__verify_grouping(char const*, unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)':
: undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> >::size() const'
/tmp/ccsbrTRT.o(.text+0x60): In function `std::__verify_grouping(char const*, unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)':
: undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator[](unsigned int) const'
/tmp/ccsbrTRT.o(.text+0x9f): In function `std::__verify_grouping(char const*, unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)':
: undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator[](unsigned int) const'
/tmp/ccsbrTRT.o(.text+0xce): In function `std::__verify_grouping(char const*, unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)':
: undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> >::operator[](unsigned int) const'
/tmp/ccsbrTRT.o(.text+0x127): In function `main':
: undefined reference to `std::cout'
/tmp/ccsbrTRT.o(.text+0x12c): In function `main':
: undefined reference to `std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)'
/tmp/ccsbrTRT.o(.text+0x155): In function `__static_initialization_and_destruction_0(int, int)':
: undefined reference to `std::ios_base::Init::Init()'
/tmp/ccsbrTRT.o(.text+0x170): In function `__static_initialization_and_destruction_0(int, int)':
: undefined reference to `std::ios_base::Init::~Init()'
/tmp/ccsbrTRT.o(.eh_frame+0x11): undefined reference to `__gxx_personality_v0'
collect2: ld a retourné 1 code d'état d'exécution
/tmp> 

Étapes de compilation

Autres options courantes en ligne de commande

• -o pour donner le nom du fichier produit
• -D (define) pour définir des symboles du préprocesseur
• -I (include) pour ajouter des répertoires où chercher les fichiers d'en-tête
• -l (library) pour lier avec une bibliothèque
• -L pour ajouter des répertoires où chercher les bibliothèques
• -Wall (warn all) pour avoir plus d'avertissements
• -g (debug) pour compiler un exécutable débugable (avec symboles)
• -O, -O1, -O2, -O3, -Os (optimize) pour optimiser
• -ansi -pedantic pour être averti des déviations du standard
• man gcc

exemple de compilation

g++ -c hello.cc -DLINUX -I../mylibs/include -Wall -g -O -ansi

exemple d'édition des liens

g++ hello.o -L../mylibs -lmy -o hello

Sortie du préprocesseur

/tmp> gcc -E hello.cc >hello.E
/tmp> ls -l hello.E
-rw-rw-r--  1 marc marc 716014 2006-01-23 06:30 hello.E
/tmp> less hello.E

• Le préprocesseur inclu tous les *.h et sort tout d'une traite (716014 octets).
• La sortie du préprocesseur est l'entrée du compilateur.
• Observer la sortie aide à comprendre certaines erreurs de compilation.

Sortie du compilateur

• Fichier en langage assembleur (x86)

/tmp> g++ -S hello.cc
/tmp> cat hello.s

Sortie de l'assembleur

• Fichier objet à lier pour avoir un exécutable

/tmp> gcc -c hello.cc
/tmp> nm hello.o --demangle
00000044 t global destructors keyed to main
0000005c t global constructors keyed to main
         U __gxx_personality_v0
00000074 T main
00000000 t __static_initialization_and_destruction_0(int, int)
         U std::ios_base::Init::Init()
         U std::ios_base::Init::~Init()
         U std::cout
00000000 b std::__ioinit
         U std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)

Projet avec plusieurs fichiers sources

// fichier standard
// distribué avec GCC

#ifndef C_H
#define C_H
char b(void);
char id(char);
#endif

#include <iostream>
#include "c.h"

int main () {
  std::cout<<b()<<id('a')<<"r\n";
}

#include "c.h"

char b(void)
{ return 'b'; }

char id(char c)
{ return c; }

• taille d'un projet : de l'ordre de 10 à 10000 fichiers
• Chaque *.cc inclut son *.h et les *.h déclarant les autres types, fonctions, etc., utilisés.
• L'inclusion de son propre *.h aide à vérifier la cohérence déclarations/implémentation.
• #ifndef de garde contre la ré-inclusion de c.h
• C++ laisse entière liberté quant au nom des fichiers.

Compilations et édition des liens (linking)

/tmp> g++ -c c.cc
/tmp> g++ -c main.cc
/tmp> ls -l *.o
-rw-rw-r--  1 marc marc  691 2006-01-13 00:32 c.o
-rw-rw-r--  1 marc marc 2688 2006-01-13 00:32 main.o
/tmp> g++ main.o c.o -o foo
/tmp> ls -l foo
-rwxrwxr-x  1 marc marc 13970 2006-01-13 15:20 foo
/tmp> ./foo
bar
/tmp>

• On compile séparément chaque fichier *.cc, ce qui produit des fichiers objet *.o.
• On lie les *.o pour produire un exécutable.
• En principe, on écrit les commandes de compilations dans un Makefile ou un IDE.

Mélange C/C++

#include "c.h"

char b(void)
{
  return 'b';
}

char id(char c)
{
  return c;
}

#ifndef C_H
 #define C_H
 #ifdef __cplusplus
  extern "C" {
 #endif
 char b(void);
 char id(char);
 #ifdef __cplusplus
  }
 #endif
#endif

#include <iostream>
#include "c.h"

int main()
{
  std::cout << b()
            << id('a')
            << 'r'
            << std::endl;
}

/tmp> gcc -c c.c
/tmp> g++ -c main.cc
/tmp> ls -l *.o
-rw-rw-r--  1 marc marc  682 2006-01-13 00:32 c.o
-rw-rw-r--  1 marc marc 2680 2006-01-13 00:32 main.o
/tmp> g++ main.o c.o -o foo
/tmp> ./foo
bar

• Il est courant d'utiliser une bibliothèque en C (comme la plupart des bibliothèques système) avec un programme en C++.

Différence entre fichiers objet C/C++ : name mangling

/* c.c */
char b (void) { return 'b'; }

// cc.cc
char b(void);  // déclaration sans extern "C"
int main () { b(); }

/tmp> gcc -c c.c
/tmp> nm c.o
00000000 T b
/tmp> g++ -c cc.cc
/tmp> nm cc.o
         U __gxx_personality_v0
00000000 T main
         U _Z1bv
/tmp> g++ c.o cc.o
cc.o(.text+0x12): In function `main':
: undefined reference to `b()'
collect2: ld a retourné 1 code d'état d'exécution

• Les compilations C et C++ ne mettent pas les mêmes symboles dans les objets.
• Ici, l'éditeur de lien n'est pas capable de faire le lien entre b et _Z1bv.
• C'est pour cela qu'il faut utiliser extern "C".
• C'est une partie de la problématique générale de l'ABI C++ (Application Binary Interface).

C++ ABI (Application Binary Interface)

• L'ABI dépend entre autres de :
  • la représentation binaire des objets (types simples, classes, etc.) ;
  • la façon d'appeler les fonctions ;
  • la construction et destruction des objets ;
  • la transmission des exceptions ;
  • l'instantiation des templates ;
  • du name mangling.
• L'ABI a (eu) tendance a changer avec chaque nouvelle version de compilateur et à être incompatibles entre compilateurs, d'où :
  • incompatibilité des objets produits par deux compilateurs différents ;
  • incompatibilités des bibliothèques C++.
• Un effort d'ABI C++ vendor-neutral multi-plateformes a (eu ?) lieu.
  • G++ 3.2 et 3.3 utilisent l'ABI C++ version 1 ;
  • G++ 3.4 et 4.0 utilisent l'ABI C++ version 2.
• Expérience personnelle :
  • Devoir utiliser Borland C++ pour Windows 3.1 (16 bits) en 2002 pour maintenir un logiciel dépendant d'une bibliothèque C++ closed source abandonnée ;
  • Morale : utiliser uniquement des composants C++ dont on a la source (de toute façon c'est obligé pour les templates).

Création de types

« Le but du concept de classe de C++ est de fournir au programmeur un outil pour créer de nouveaux types qui peuvent être utilisés aussi aisément que les types prédéfinis.» (Stroustrup)

Exemple de tels types : std::string et std::ostream.

#include <string>
#include <iostream>

int main ()
{
  std::string h = "hello";
  std::string w = "world";
  h += ", ";        // Appond une chaîne avec +=
  w = h + w + '\n'; // Concaténation avec +, assignation avec =
  std::cout << w;   // Affichage du tout avec <<
}

/tmp> ./a.out
hello, world

• Les habitués du C constateront qu'on n'a pas besoin de se soucier de la gestion de la mémoire occupée par les chaînes de caractères.

Type concret

• Un type « concret » est un type implémentant efficacement un concept simple, indépendant d'autres types, supportant toutes les opérations courantes.
• Quelques types concrets classiques : date, std::complex, big_num, BCD, std::vector, std::pair, std::auto_ptr.
• Avant la bibliothèque standard, chacun, chaque bibliothèque, implémentait son propre type String (comme les QString de Qt).
• En pratique, on utilise beaucoup les types concrets mais on les code rarement soit-même.
• L'interaction avec les subtilités du langage rendent très difficile la création d'un bon type concret d'usage général. Ça nécessite de se frotter à de nombreux concepts de C++, ce qui fait une bonne base de tutoriel…

Création d'un type Fraction (1/9)

#include <iostream>
#include "fraction.h" // contient la déclaration de Fraction
int main () {
  Fraction f1 (6, 8); // = 6/8 = 3/4
  Fraction f2 = 2;    // = 2/1
  Fraction f3;        // non initialisé
  Fraction f4 = f1;   // = f1
  f3 = f1;
  f3 = Fraction(1, 4) + f3;
  f2 = f2 * f1 + 1;
  std::cout<<"f1 = "<<f1<<"\nf2 = "<<f2<<"\nf3 = "<<f3<<'\n';
}

/tmp> ./a.out
f1 = 3/4
f2 = 5/2
f3 = 1

• Initialisation avec 1 entier, 2 entiers, une autre fraction ou pas d'initialisation.
• Affectation d'un entier ou une autre fraction
• Addition et multiplication avec un entier ou une fraction.
• Réduction automatique de la fraction
• Affichage de la fraction avec << et sans diviseur lorsqu'il vaut 1

Fraction : Structure (2/9)

#include <iostream>
struct Fraction {
  int numerateur;
  int diviseur;
};
int main () {
  Fraction f1 = {6, 8}; // initialisation
  Fraction f2 = {2};    // diviseur non initialisé !
  Fraction f3;          // non initialisation OK
  Fraction f4 = f1;     // initialisation avec une fraction OK
  f3 = f1;              // assignation d'une fraction OK
  std::cout<<f1.numerateur<<'/'<<f1.diviseur<<'\n';
}

/tmp> ./a.out
6/8

• struct de C
• l'initialisation avec un entier donne une fraction indéfinie
• l'assignation est générée par le compilateur
• pas d'opération arithmétique
• pas de réduction
• affichage en accédant explicitement au numérateur et diviseur

Fraction : ajout d'une méthode (3/9)

#include <iostream>

struct Fraction {
  int numerateur, diviseur;
  void reduire ();
};

int main ()
{
  Fraction f1 = {6, 8}; // initialisation
  f1.reduire();         // transforme 6/8 en 3/4
  std::cout<<f1.numerateur<<'/'<<f1.diviseur<<'\n';
}

/tmp> ./a.out
3/4

• reduire est une méthode de Fraction
• On l'utilise avec l'opérateur . comme pour les autres membres
• La méthode reduire modifie l'objet f1 pour lequel elle est appelée.

Fraction : implémentation de la méthode (4/9)

struct Fraction {
  int numerateur, diviseur;
  void reduire ();
};

void Fraction::reduire ()
{
  if (diviseur < 0) {
    numerateur = -numerateur;
    diviseur = -diviseur;
  }
  int a = std::abs(numerateur), b = diviseur, c;
  while (b != 0) {
    c = a % b;
    a = b;
    b = c;
  }
  numerateur /= a;
  diviseur /= a;
}

• Les méthodes sont dans le scope de leur classe (Fraction::).
• Les méthodes ont accès à tous les membres de la classe.

this

// méthode de Fraction
void Fraction::fun () {
        numerateur = 0;  // équivalent
  this->numerateur = 0;  // équivalent
}

// fonction agissant sur une Fraction
void fun (Fraction * This) {
  This->numerateur = 0;
}

void f () {
  Fraction f;
  f.fun();   // appel de méthode
  fun(&f);   // appel de fonction
}

• Une méthode reçoit implicitement this, un pointeur sur l'objet concerné par l'appel de la méthode.
• Dans une méthode, il est inutile d'écrire this-> pour accéder aux membres.

Fraction : ajout d'un constructeur (5/9)

struct Fraction {
  int numerateur, diviseur;
  Fraction(int, int);
  void reduire();
};
Fraction::Fraction(int n, int d)
  : numerateur (n), diviseur (d) { reduire(); }
int main () {
  Fraction f1 (3, 4);  // construction avec 2 entiers OK
  Fraction f2 (2);     // construction avec 1 entier
  Fraction f2 = {2, 1};// initialisation littérale
  Fraction f3;         // pas d'initialisation
  Fraction f4 = f1;    // construction par copie OK
  f3 = f1;             // assignation d'une fraction OK
}

Fraction : surcharge du constructeur (6/9)

struct Fraction {
  int numerateur, diviseur;
  Fraction(int n, int d): numerateur (n), diviseur (d) { reduire(); }
  Fraction(int n)       : numerateur (n), diviseur (1) {}
  Fraction() {}
  void reduire();
};

int main ()
{
  Fraction f1 (3, 4); // Fraction(int, int)
  Fraction f2 = 2;    // Fraction(int)
  Fraction f3;        // Fraction()
  Fraction f4 = f1;   // Fraction(const Fraction&)
}

• Le nombre de paramètres détermine quel constructeur surchargé est appelé.
• En général, la signature (nombre et type des paramètres) de fonctions surchargées détermine laquelle est appelée.
• Définir une méthode tout en la déclarant la rend inline. Autre solution également dans le fichier d'en-tête :

  inline Fraction::Fraction() {}
  

Fraction : paramètre par défaut (7/9)

struct Fraction {
  int numerateur, diviseur;
  Fraction (int, int = 1);
  Fraction () {}
  void reduire ();
};

// Implémentation
Fraction::Fraction(int n, int d)
  : numerateur (n), diviseur (d) { reduire(); }

int main ()
{
  Fraction f1 (3, 4); // Fraction(int, int);
  Fraction f2 (2);    // Fraction(int, int = 1);
  Fraction f3;        // Fraction();
  Fraction f4 = f1;   // Fraction(const Fraction&)
}

• Permet de rendre des paramètres optionnels lorsqu'une valeur par défaut est possible.
• Fraction(int = 0, int = 1) est aussi possible, mais il faut alors supprimer Fraction() pour éviter l'ambiguïté.
• Les paramètres par défaut ne sont pas répétés dans la définition.

Fraction : Surcharge d'opérateur (8/9)

#include "fraction.h"

Fraction operator + (Fraction lhs, Fraction rhs)
{
  return Fraction (lhs.numerateur * rhs.diviseur +
                   rhs.numerateur * lhs.diviseur,
                   lhs.diviseur * rhs.diviseur);
}

int main ()
{
  Fraction f1 (3, 4);
  f1 = operator + (f1, Fraction (1, 4));
  f1 = f1 + Fraction (1, 4);
  f1 = operator + (f1, 3);
  f1 = f1 + 3;
}

• Un opérateur surchargé est une fonction comme une autre, sauf que l'appel peut prendre la forme d'un opérateur infixé.
• On peut surcharger mais pas rédéfinir un opérateur (int operator+(int,int)).
• On constate qu'un constructeur revient à permettre une conversion automatique de type avec operator+(f1,3).

Fraction : Surcharge d'autres opérateurs

// Fraction(1,2) * Fraction(3,4)
Fraction operator * (Fraction lhs, Fraction rhs) {
  return Fraction f(lhs.numerateur * rhs.numerateur,
                    lhs.diviseur   * rhs.diviseur);
}

// std::cout << Fraction(1,2)    << '\n';
#include <ostream>
std::ostream & operator << (std::ostream & s, Fraction f) {
  s << f.numerateur;
  if (f.diviseur != 1)
    s << '/' << f.diviseur;
  return s;
}

// quelques autres opérateurs utiles
bool operator==(Fraction, Fraction);  // opérateur binaire
Fraction& Fraction::operator+=(Fraction); // op. binaire membre
Fraction operator-(Fraction);        // opérateur unaire
Fraction operator++(Fraction&);      // opérateur préfixé
Fraction operator++(Fraction&, int); // opérateur postfixé
Fraction::operator double() const;   // opérateur de conversion

Fraction : Réponse finale (9/9)

fraction.h

#ifndef FRACTION_H
#define FRACTION_H

#include <iosfwd>

struct Fraction {
  int numerateur, diviseur;
  Fraction ();
  Fraction (int, int = 1);
  void reduire ();
};

Fraction operator + (Fraction, Fraction);
Fraction operator * (Fraction, Fraction);
std::ostream & operator << (std::ostream &, Fraction);

#endif

fraction.cc

#include "fraction.h"
#include <cstdlib>
#include <ostream>

Fraction::Fraction() {}

Fraction::Fraction(int n, int d)
: numerateur (n), diviseur (d)
{
  reduire();
}

Fraction operator * (Fraction lhs, Fraction rhs)
{
  return
    Fraction f(lhs.numerateur * rhs.numerateur,
               lhs.diviseur   * rhs.diviseur);
}

Fraction operator + (Fraction lhs, Fraction rhs)
{
  return
    Fraction f(lhs.numerateur * rhs.diviseur +
               rhs.numerateur * lhs.diviseur,
               lhs.diviseur * rhs.diviseur);
}

std::ostream & operator << (std::ostream & s, Fraction f)
{
  s << f.numerateur;
  if (f.diviseur != 1)
    s << '/' << f.diviseur;
  return s;
}

void Fraction::reduire ()
{
  if (diviseur < 0) {
    numerateur = -numerateur;
    diviseur = -diviseur;
  }
  // PGCD numerateur et diviseur
  int a = std::abs(numerateur), b = diviseur, c;
  while (b != 0) {
    c = a % b;
    a = b;
    b = c;
  }
  numerateur /= a;
  diviseur /= a;
}

Fraction « défensive »

• diviseur nul impossible :
  • initialisation valide assurée par le constructeur
  • numérateur et diviseur uniquement accessibles en lecture
• réduite par construction

class Fraction {  // class au lieu de struct
  int numerateur_, diviseur_; // membres privés
public:
  class DiviseurNul {};
  Fraction (int n = 0, int d = 1)
    : numerateur_(n), diviseur_(d)
    { if (diviseur_ == 0) throw DiviseurNul(); reduire(); }
  int numerateur () const { return numerateur_; }
  int diviseur () const { return diviseur_; }
  void reduire ();
};

void f() {
  Fraction f (0, 0); // exception Fraction::DiviseurNul
  f.numerateur;      // erreur, numerateur est une méthode
  f.numerateur_;     // erreur, numerateur_ est privé
  f.numerateur();    // OK, méthode publique
}

Const-correctness

class Fraction {
//...
  int numerateur ();  // peut modifier l'objet
  int numerateur () const;  // ne modifie pas l'objet
};
void func1(Fraction &);  // peut modifier le paramètre
void func2(const Fraction &); // ne modifie pas le paramètre

void f () {
  const Fraction quart (1, 4);
  quart.numerateur ();  // int numerateur () const
}

• La const-correctness est une discipline de programmation très utilisée en C++ pour détecter à la compilation des modifications imprévues d'objet.
• Il est mauvais d'oublier le const d'un passage de paramètre par référence ou pointeur.
• Il est mauvais d'oublier le const d'une méthode qui ne modifie pas l'objet.
• Le const_cast permet de passer outre (pour utiliser des fonctions mal conçues) :

  void lib_func(Fraction * f);  // ne modifie en fait pas f
  void proxy_lib_func(const Fraction * f) {
    lib_func(const_cast<Fraction*>(f));
  }
  

Type gérant automatiquement une ressource

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

void probleme (const char *filename)
{
  const int fd = open(filename, O_RDONLY);
  //...
  if (write (fd, buf, count) == -1)
     return;  // sortie sans close(f)
  essai();  // fonction pouvant lancer une exception
  //...
  close(f);
}

• Problématique : Comment s'assurer que la ressource (ici un descripteur de fichier) soit libérée lorsqu'on n'en a plus besoin ?
• En C++, le problème se pose notamment pour gérer la mémoire avec new et delete.
• Réponse : Créer un type dont le constructeur alloue et le destructeur désalloue : resource acquisition is initialization.

Resource acquisition is initialization

class FileHandle {
  const int handle;
public:
  FileHandle(const char* filename, int flags)
    : handle (open(filename, flags)) {}
  ~FileHandle() { close(handle); }
  operator int() const { return handle; }
};

void solution (const char *filename)
{
  const FileHandle fd (filename, O_RDONLY);
  //...
  if (write (fd, buf, count) == -1)
    return;
  //...
  // close automatique par FileHandle::~FileHandle
}

• Le constructeur alloue la ressource et le destructeur la libère.
• La méthode operator int() const permet d'utiliser un objet FileHandle comme un descripteur classique (write(fd, ).
• Problème : double-destruction si on copie fd !

Problèmes de copie d'objet

void r (const FileHandle & handle) {
  // handle est une référence à l'objet de l'appelant
  /* ... */
}

void v (FileHandle handle) {
  // handle est un nouvel objet construit par copie du paramètre
  /* ... */
  // destruction de handle, appel automatique de close
}

void g () {
  FileHandle h (".file", O_RDONLY), h2 (".file2", O_RDONLY);
  h2 = h;  // assignation
  r(h);  // r reçoit une référence à h
  v(h);  // v reçoit une copie de h
  // destruction de h et h2, ".file" fermé 3 fois, ".file2" 0
}

• C(C&); constructeur de copie, automatiquement utilisé pour passer des paramètres, transmettre les exceptions, initialiser par copie.
• C&operator=(C&); opérateur d'assignation, automatiquement utilisé pour l'assignation.
• Le comportement par défaut ne convient souvent pas aux objets complexes.

Objet incopiable

class FileHandle {
  const int handle;
  FileHandle(const FileHandle&);  // Pas de copie
  FileHandle& operator=(const FileHandle&);  // Pas d'assignation
public:
  FileHandle(const char* filename, int flags)
    : handle (open(filename, flags)) {}
  ~FileHandle() { close(handle); }
  operator int() const { return handle; }
};

void f1 (FileHandle);
void f2 (const FileHandle &);

int main () {
  FileHandle h (".file", 0), h2 (".file2", 0);
  h2 = h;  // impossible d'assigner
  f1 (h);  // impossible de construire par copie
  f2 (h);  // OK
}

• En déclarant le constructeur de copie et l'opérateur d'assignation privés, les objets de la classe deviennent incopiables.
• On ne peut plus les passer par valeur, mais le passage par référence reste OK.

Copie avec transfert de possession

class FileHandle {
  bool owner;
  int handle;
public:
  FileHandle (FileHandle& from)
    : owner(from.owner), handle(from.handle)
    { from.owner = false; }  // possession transférée

  FileHandle& operator= (FileHandle& from) {
    if (&from != this) {  // cas handle=handle;
      if (owner) close(handle);  // possession abandonnée
      handle = from.handle;
      owner = from.owner;
      from.owner = false;  // nouvelle possession transférée
    }
    return *this;
  }

  ~FileHandle () { if (owner) close(handle); }
};

• La possession est transférée par la copie, seul le possesseur ferme le fichier.

Exemples de comportements en cas de copie

• std::auto_ptr transfère la possession.
• boost::scoped_ptr a une possession intransférable.
• boost::shared_ptr partage et compte la possession.
• std::string duplique la chaîne, parfois en différé (lazy evaluation et reference counting).
• La construction par copie et l'assignation sont deux fonctionnalités délicates des classes dont la simple duplication binaire des membres ne donne pas un résultat satisfaisant.

Programmation orientée objet

Ce cours ne couvre que le support que C++ donne à la POO.

1. On fait une conception orientée objet.
2. On implémente dans un langage de son choix.
3. Certains langages supportent mieux que d'autres les concepts de la POO :
   • les classes
   • les objets (= une instance de classe)
   • l'encapsulation (on peut cacher des choses dans les classes)
   • l'héritage (une classe peut hériter d'une autre)
   • l'abstraction (un objet Chien peut être traité comme un objet Animal)
   • le polymorphisme (un objet Chien et un Chat implémente crier différemment)
4. C++ supporte directement tout cela.

Exemple : wc (word count)

~ > wc </usr/share/common-licenses/GPL
  340  2968 17992

Objets

• un flux de caractères entrants
• une sortie de caractères
• un compteur pouvant être (selon paramètres en ligne de commande) :
  • un compteur de lignes
  • un compteur de mots
  • un compteur de lettres
  • un compteur de tout (lignes, mots et lettres)

Schéma hiérarchique des compteurs

wc : Utilisation des classes

#include "compteur.h"
#include <iostream>

int main(int argc, char * argv[])
{
  char c;
  Compteur*const compteur = MakeCompteur(argv[1]); // abstraction

  while (std::cin.get(c))
    compteur->Compter(c);  // polymorphisme
  std::cout << *compteur << '\n';
  delete compteur;
}

• MakeCompteur retourne un objet de type CompteurDeLettres, CompteurDeMots, CompteurDeLignes ou CompteurDeTout. On se fiche de savoir lequel (abstraction).
• Chaque type de compteur compte à sa manière (polymorphisme) mais est utilisable avec :

  void Compteur::Compter(char);
  

• On ne peut afficher le résultat qu'en appelant l'opérateur << pour ostream et Compteur (encapsulation).

  std::ostream& operator<<(std::ostream&, Compteur&);
  

wc : MakeCompteur (fabrique de compteur)

#include "compteur.h"

Compteur * MakeCompteur(const char* arg)
{
  if (arg && arg[0] == '-') {
    if (arg[1] == 'w') return new CompteurDeMots;
    if (arg[1] == 'l') return new CompteurDeLignes;
    if (arg[1] == 'm') return new CompteurDeLettres;
  }
  return new CompteurDeTout;
}

• Un Compteur* permet de pointer sur CompteurDeMots, CompteurDeLignes, etc. car :
  • Compteur est une classe de base public de CompteurDeMots ;
  • (équivalent) CompteurDeMots est une classe publiquement dérivée de Compteur.
  • (équivalent) CompteurDeMots hérite publiquement de Compteur.
• Un Compteur* ou un Compteur& permet de pointer/référencer tout objet d'une classe publiquement dérivée.

  Compteur* pc = new CompteurDeMots; // OK
  Compteur& rc = *pc; // OK
  

• Avec un Compteur* ou un Compteur& on ne peut bien sûr utiliser que ce qui est déclaré dans la classe Compteur, donc commun à tous les compteurs.

wc : Héritage publique (IS-A)

class Compteur {
  public: virtual void Compter(char);
};
class CompteurDeLettres : public Compteur {
  public: void Compter(char);
};
class CompteurDeMots    : public Compteur {
  public: void Compter(char);
};
class CompteurDeLignes  : public Compteur {
  public: void Compter(char);
};
class CompteurDeTout    : public Compteur {
  public: void Compter(char);
};
std::ostream& operator<<(std::ostream&, const Compteur&);

• La classe de base Compteur déclare Compter, qui est commun à tous les compteurs.
• Seules les méthodes déclarées virtuelles peuvent être redéfinies.
• Chaque classe dérivée de Compteur (relation IS-A) redéfinit la méthode virtuelle Compter à sa manière.
• operator<< est déclaré comme fonction amie plutôt que membre car le paramètre de gauche doit être un ostream. Problème : Ne peut pas être virtuel ni redéfinit.

wc : Méthodes virtuelles (pures), classe abstraite

#include <iosfwd>

class Compteur {
public:
  virtual void Compter(char) = 0;  // méthode virtuelle pure
  virtual ~Compteur() {}  // méthode (destructeur) virtuelle
  // fonction amie
  friend std::ostream& operator<<(std::ostream&, const Compteur&);
private:
  virtual std::ostream& Output(std::ostream&) const = 0;
};

std::ostream& operator<<(std::ostream&, const Compteur&);

• Compteur est une classe abstraite (une interface) car elle contient des méthodes virtuelles pures.
• Il est donc impossible de construire un objet Compteur : Compteur c; ne compile pas.
• Les classes dérivées fournissent (override) une définition de Compter et Output.
• Output est une méthode virtuelle pure privée que operator<< peut appeler pour résoudre son problème de non virtualité.
• operator<< est ami pour pouvoir appeler la méthode privée Output.
• En règle générale, le destructeur d'une classe de base doit être virtuel.

wc : classe dérivée

#include <ostream>
#include <iomanip>

class Compteur {
public:
  virtual void Compter(char) = 0;
  virtual ~Compteur() {}
  friend std::ostream & operator<<(std::ostream &, const Compteur &);
private:
  virtual std::ostream & Output(std::ostream &) const = 0;
};

std::ostream& operator<<(std::ostream& strm, const Compteur& compteur)
{ return compteur.Output(strm); }

class CompteurDeLettres : public Compteur {
public:
  void Compter(char c) { ++compte; }
private:
  int compte;
  std::ostream & Output(std::ostream & strm) const
  { return strm << std::setw(4) << compte; }
};

wc : composition (HAS-A)

class CompteurDeTout : public Compteur {
public:
  void Compter(char);
private:
  std::ostream & Output(std::ostream &) const;
  CompteurDeLignes lignes;   // HAS-A
  CompteurDeMots mots;       // HAS-A
  CompteurDeLettres lettres; // HAS-A
};

void CompteurDeTout::Compter(char c)
{
  lettres.Compter(c);
  mots.Compter(c);
  lignes.Compter(c);
}

std::ostream & CompteurDeTout::Output(std::ostream & strm) const
{
  return strm << lignes << ' ' << mots << ' ' << lettres;
}

wc : rassembler les propriétés communes

• On peut rassembler dans CompteurSimple ce qui est commun aux compteurs qui ont un seul membre compte.

wc : membre protégé

class CompteurSimple : public Compteur {
  public: CompteurSimple();
  protected: int compte;
  private: std::ostream & Output(std::ostream &) const;
};

class CompteurDeLettres : public CompteurSimple {
  public: void Compter(char);
};

class CompteurDeLignes : public CompteurSimple {
  public: void Compter(char);
};

class CompteurDeMots : public CompteurSimple {
public:
  CompteurDeMots();
  void Compter(char);
private:
  bool last_in_word;
};

• compte est protégé, ce qui permet aux classes dérivées d'y accéder (pour l'incrémenter) sans le rendre public.
• Note : Déclarer une variable non privée est stylistiquement critiqué.

wc : compteur.h

#ifndef COMPTEUR_H
#define COMPTEUR_H

#include <ostream>

class Compteur {
public:
  virtual void Compter(char) = 0;
  virtual ~Compteur() {}
  friend std::ostream & operator<<(std::ostream &, const Compteur &);
private:
  virtual std::ostream & Output(std::ostream &) const = 0;
};

std::ostream & operator<<(std::ostream &, const Compteur &);

class CompteurSimple : public Compteur {
public:
  CompteurSimple();
protected:
  int compte;
private:
  std::ostream & Output(std::ostream &) const;
};

class CompteurDeLettres : public CompteurSimple {
public:
  void Compter(char);
};

class CompteurDeLignes : public CompteurSimple {
public:
  void Compter(char);
};

class CompteurDeMots : public CompteurSimple {
public:
  CompteurDeMots();
  void Compter(char);
private:
  bool last_in_word;
};

class CompteurDeTout : public Compteur {
public:
  void Compter(char);
private:
  CompteurDeLignes lignes;
  CompteurDeMots mots;
  CompteurDeLettres lettres;
  std::ostream & Output(std::ostream &) const;
};

#endif

Composition et encapsulation, une base de la POO

class FileOpenDialog : public Dialog { TextInput filter_text; TextList directories_list; TextList files_list; Button open; Button filter; Button cancel; Button help; public: FileOpenDialog(const string& dir); }; En général, une classe applicative suffit à remplir un fichier d'en-tête et un fichier source pour l'implémentation.

Héritage, une base de la POO

L'abstraction et le polymorphisme sont très adaptés à la représentation des règles business avec toutes leurs variantes.

class Compte { /*...*/ };
class ComptePersonnel : public Compte { /*...*/ };
class ComptePersonnelEUR : public ComptePersonnel { /*...*/ };
class ComptePersonnel60Plus : public ComptePersonnel { /*...*/ };
class ComptePersonnelGeneration : public ComptePersonnel { /*...*/ };
class ComptePersonnelCampus : public ComptePersonnel { /*...*/ };
class CompteCourant : public Compte { /*...*/ };
class CompteEpargne : public Compte { /*...*/ };
class CompteEpargneBonus : public CompteEpargne { /*...*/ };
class CompteEpargneJeunesse : public CompteEpargne { /*...*/ };
class CompteFondPlacement : public Compte { /*...*/ };
class CompteATerme : public Compte { /*...*/ };

wc : Par héritage multiple virtuel, schéma

• Note : Démonstration de fonctionnalité seulement, sans garantie de de bon goût stylitique.
• L'idée est qu'un CompteurDeTout est un seul Compteur et est aussi un CompteurDeLignes, un CompteurDeMots et un CompteurDeLettres.

wc : Par héritage multiple virtuel

class Compteur { /* ... */ };
class CompteurSimple   : virtual public Compteur { /* ... */ };
class CompteurDeLettres: public CompteurSimple { /* ... */ };
class CompteurDeMots   : public CompteurSimple { /* ... */ };
class CompteurDeLignes : public CompteurSimple { /* ... */ };

class CompteurDeTout
: public CompteurDeLignes
, public CompteurDeMots
, public CompteurDeLettres {
public:
  void Compter(char);
protected:
  std::ostream & Output(std::ostream &) const;
};

void CompteurDeTout::Compter(char c)
{
  CompteurDeLettres::Compter(c);
  CompteurDeMots::Compter(c);
  CompteurDeLignes::Compter(c);
}

std::ostream & CompteurDeTout::Output(std::ostream & strm) const
{
  CompteurDeLignes::Output(strm) << ' ' <<
  CompteurDeMots::Output(strm) << ' ' <<
  CompteurDeLettres::Output(strm);
  return strm;
}

• Sans le virtual public, CompteurDeTout aurait trois classes de base Compteur, autrement dit Compteur serait une classe de base ambiguë de CompteurDeTout, donc CompteurDeTout* ne pourrait pas être converti en Compteur*.
• Si on dérivait virtuellement de ComteurSimple, on n'aurait plus qu'une variable compte incrémentée par tous les compteurs.

Héritage privé

class Incopiable {
  Incopiable(Incopiable&);
  Incopiable& operator=(Incopiable&);
public:
  Incopiable() {}
};

class CompteurDeTout : public Compteur, Incopiable { /*...*/ };

void f () {
  CompteurDeTout compteur;
  Compteur * pc = &compteur;
  Incopiable * pi = &compteur;
}

• Les utilisateurs ne peuvent pas dépendre d'une base privée.
• L'héritage privé sert donc à masquer les détails d'implémentation.

Exceptions

class Stack {
  char* v;
  int max_size;
  int top;
public:
  class UnderFlow {};
  class OverFlow {};

  Stack(int size);
  ~Stack();
  void Push(char);
  char Pop();
};

void Stack::Push(char c) {
  if (top == max_size) throw OverFlow();
  v[top++] = c;
}

char Stack::Pop() {
  if (top == 0) throw UnderFlow();
  return v[--top];
}

Capture d'exception

void f () {
  Stack stk(3);
  try {
    stk.Push("foo");
  } catch (const Stack::Overflow & e) {
    Alerte();
  } catch (const Stack::Underflow & e) {
    Oups();
  } catch (...) {
    Arg();
  }
}

Spécifications d'exception

void f () throw (E1);

• Indique quelles exceptions peut jeter une méthode.
• Très peu utilisé.
• Inutilisable avec des conteneurs génériques car on ne sait pas quelle exception l'objet générique peut lancer.

Templates

template <typename T>
const T& Max (const T& a, const T& b)
{
  return a > b ? a : b;
}

#include <iostream>
#include <string>
using namespace std;
int main ()
{
  cout << Max (5, 3) << ' '  // int max(int,int)
       << Max ('a', 'z') << ' '  // char max(char,char)
       << Max (1.21e-5, 0.0000131) << ' '  // float max(float,float)
       << Max (string("titi"), string("toto")) << ' '  // std::string max(std::string,std::string
       << Max<int>(100, 'Z') << '\n';
}

5 z 1.31e-05 toto 100

• Le code de la fonction est généré (le template est instancié) pour chaque type.
• Lorsque les types diffèrent, il faut en préciser un.
• std::max et std::min existent.

Instantiation des templates

• Pour générer le code, le compilateur doit voir la définition de la fonction template.
• Modèle Borland (et G++) :
  • La déclaration et la définition des templates sont dans les fichiers d'en-tête.
  • Les templates nécessaires sont instanciés dans chaque fichiers objet.
  • Le linker supprime les générations redondantes entre objets.
• Le mot clé export qui permettrait de mettre les définitions hors des fichiers d'en-tête est très peu supporté. Cela demande au compilateur de maintenir un répertoire d'instances de templates.

  // max.h
  template <typename T>
  const T& Max (const T& a, const T& b);
  

  // max.cc
  export template <typename T>
  const T& Max (const T& a, const T& b)
  { return a > b ? a : b; }
  

Classe template

template<class T> class Stack {
  T* v;
  int max_size;
  int top;
public:
  class UnderFlow {};
  class OverFlow {};
  Stack(int size);
  ~Stack();
  void Push(T);
  T Pop();
};

template<class T> void Stack<T>::Push(T c) {
  if (top == max_size) throw OverFlow();
  v[top++] = c;
}

template<class T> T Stack<T>::Pop() {
  if (top == 0) throw UnderFlow();
  return v[--top];
}

Spécialisation de template

#include <cstring>

template <class T> void Copy (T * dest, const T * source)
{
  while (*dest++ = *source++);
}

template <char> void Copy (char * dest, const char * source)
{
  std::strcpy (dest, source);
}

int main()
{
  char sc[] = { 'h', 'e', 'l', 'l', 'o', '\0' };
  int si[] = { 1, 2, 3, 4, 5, 0 };
  char tc[10];
  int ti[10];
  Copy (tc, sc);
  Copy (ti, si);
}

• Utile pour optimiser ou faire varier le comportement.

Spécialisation partielle de template

template<class T> class Vector<T> { /*...*/ };
template<> class Vector<void*> { /*...*/ };

template <class T> class Vector<T*> : private Vector<void*> {
public:
  typedef Vector<void*> Base;
  Vector() : Base() {}
  explicit Vector(int i) : Base(i) {}
  T*& elem(int i)
    { return static_cast<T*&>(Base::elem(i)); }
  T*& operator[](int i)
    { return static_cast<T*&>(Base::operator[] (i)); }
};

• Principe :
  • Une classe générique Vector
  • Une spécialisation pour les pointeurs void*.
  • Une spécialisation pour tous les pointeurs T* implémentée avec la spécialisation de void*.
• Permet d'utiliser le code instancier pour void* avec tous les pointeurs, tout en conservant la vérification des types :

  Vector<double*> vd;
  Vector<Client*> vc;
  Vector<Facture*> vf;
  

Templates : métaprogrammation

• Intérêt académique
• Optimisation par génération automatique de code spécialisé
• Temps et mémoire de compilation considérables

// définition récursive
template <int N> struct factorielle {
  enum { value = N * factorielle<N-1>::value };
};

// condition terminale avec une spécialisation
template<> struct factorielle<0> {
  enum { value = 1 };
};

#include <iostream>
int main()
{
  std::cout << factorielle<0>::value << ' '
            << factorielle<1>::value << ' '
            << factorielle<2>::value << ' '
            << factorielle<3>::value << '\n';
}

• Marche aussi pour fonctions trigonométriques, etc.

Métaprogrammation et sélection de type

template <bool b, typename TRUE, typename FALSE>
struct IF;

template <typename TRUE, typename FALSE>
struct IF <true, TRUE, FALSE>
{
  typedef TRUE RESULT;
};
 
template <typename TRUE, typename FALSE>
struct IF <false, TRUE, FALSE>
{
  typedef FALSE RESULT;
};

#include <iostream>
int main()
{
  IF<true, int, float>::RESULT i = 1.23;
  IF<false, int, float>::RESULT f = 1.23;
  std::cout << i << ' ' << f << '\n';
}

• Principe : un booléen et deux types en paramètres
• Selon le booléen, IF :: RESULT est le premier ou second type.
• Permet aussi de choisir la classe de base :

  template <class T>
  class Foo : private IF <sizeof(T) <= sizeof(int), Machin, Truc> {
    //...
  };
  

• Les templates forment comme un langage dans C++.
• On ne peut utiliser que des expressions constantes car tout doit être calculable à la compilation.

Templates : Conclusion

• À l'origine, les templates ont été créé pour pouvoir créer des bibliothèques de conteneurs (tableau, listes, piles, etc.) génériques.
• Dans la bibliothèque standard, pratiquement tout est fait avec des templates, les chaines, les entrée-sortie, les list, map, vecteurs, etc.

  template<class charT,
           class traits = char_traits<charT>,
           class Allocator = allocator<charT> >
  class basic_string;
  typedef basic_string<char> string;
  
  template<class charT,
           class traits = char_traits<charT> >
  class basic_ostream;
  typedef basic_ostream<char> ostream;
  ostream cout;
  

Bibliothèque standard

• Utilitaires : pair, auto_ptr, limites numeriques, min(), max(), swap()
• La Standard Template Library (STL) :
  • conteneurs : vector, deque, list, string, set, multiset, map, multimap.
  • itérateur :
    • d'entrée : lit un istream
    • de sortie : écrit un ostream
    • forward : lit et écrit en avant
    • bidirectionnel : avant-arrière, pour list, set, multiset, map, multimap.
    • accès aléatoire : pour vector, deque, string, array.
  • algorithmes : for_each, find, count, copy, replace, remove_copy_if, reverse, random_shuffle, sort, etc.
• conteneurs spéciaux : stack, queue, priority_queue, bitset.
• valarray, table optimisée pour le calcul numérique
• streams

Conteneurs

• Sémantique de valeur, pas de référence
• Les éléments sont ordonnés et peuvent être parcouru avec un itérateur.
• Pas de vérification des bornes

Exemple : mélangeur de lignes

#include <iostream>
#include <iomanip>
#include <vector>
#include <iterator>
#include <algorithm>
using namespace std;

int main()
{
  vector<string> v;
  string line;

  while (getline(cin, line))
    v.push_back(line);
  random_shuffle(v.begin(), v.end());
  copy(v.begin(), v.end(), ostream_iterator<string>(cout, "\n"));
}

Objets fonctionnels

// random_shuffle utilise une fonction
int alea(int max) { return std::rand() % max; }

random_shuffle(v.begin(), v.end(), alea);

// random_shuffle utilise un objet
class Alea {
  int a;
public:
  Alea (int i) : a(i) {}
  int operator() (int max) { ++a; return a %= max; }
};

Alea obj (22);
random_shuffle(v.begin(), v.end(), obj);

• La surcharge de l'opérateur d'appel de fonction permet de passer un objet comme une fonction.
• La plupart des algorithmes de la bibliothèque standard sont paramétrables :

  // tri d'un vecteur de double en ordre descendant
  sort(vec.begin(), vec.end(), greater<double>);
  

Exception-safety et STL

Garantie de base et forte

Que se passe-t-il lorsqu'une exception est jetée par une opération dans un conteneur de la bibliothèque standard.

• Garantie de base : rester cohérent et ne pas perdre de ressource. En revanche l'état peut être imprévisible. Tous les conteneurs la respecte.
• Garantie forte : commit-or-rollback
  • OK pour la construction d'un nœud des conteneurs à nœuds (list, set, multiset, map, multimap). La destruction d'un nœud réussit toujours. Les opérations multi-nœuds peuvent échouer au milieu
  • Pas OK pour les conteneurs tabulaires (vector, deque), sauf si le constructeur de copie et l'assignation ne jettent pas d'exception.

Streams : Formattage de la sortie

C'est pas très joli, mais possible.

#include <iostream>
#include <iomanip>
using namespace std;

int main ()
{
  int i = 10;
  cout << i << ' ' << hex << i << ' ' << oct << i << '\n';

  double f[] = { 0, 132.456, -0.0113, 12345678 };
  cout << fixed << setprecision(2) << setfill('_');
  for (size_t i = 0; i < sizeof f / sizeof f[0]; ++i)
    cout << setw(8) << f[i] << '\n';
}

10 a 12
____0.00
__132.46
___-0.01
12345678.00

Autres streams

I/O

#include <iostream>
int main()
{
  int a, b;
  std::cout << "Entrez deux entiers :" << std::endl;
  std::cin >> a >> b;
  std::cout << "somme = " << a + b <<
               " produit = " << a * b << std::endl;
}

stringstream

#include <sstream>
std::string fullpath (const char* basedir, const char* filename)
{
  std::ostringstream strm;
  strm << basedir << '/' << filename;
  return strm.str();
}

Fichiers

#include <fstream>
int main (int argc, char *argv[])
{
  std::ifstream file (argv[1]);
  //...
}

©2006, Marc Mongenet
Ce cours est disponible selon les termes de la Creative Commons Attribution 2.5 License.