[Archive — École 42] C++ Module 02

💡 Dans son module 02 en C++, l’école 42 présente de nouvelles notions:

1. Polymorphisme ad hoc / surcharge de fonction (= différentes définitions de fonctions ayant le même nom mais prenant des paramètres différents)
2. Surcharge d’opérateur (“operator overload”)
3. Classe canonique

Polymorphisme ad hoc / surcharge de fonctions

https://cdn.intra.42.fr/video/video/94/piscine_c___-_d02_-_00_ad-hoc_polymorphism.mp4

La surcharge de fonction permet de définir plusieurs fonctions ayant le même nom mais prenant des paramètres différents.

#pragma once

class Sample 
{
 public:
  Sample(void);
  ~Sample(void);

 // 4 surcharges
 void bar(char const c) const;
 void bar(int const c) const;
 void bar(float const z) const;
 void bar(Sample const &i) const;
}

La surcharge de fonction est également possible sur des fonctions qui ne sont pas des fonctions de classe / d’instance.

Surcharge d’opérateur

https://cdn.intra.42.fr/video/video/95/piscine_c___-_d02_-_01_operator_overload.mp4

Il existe plusieurs types d’opérateurs (les opérateurs arithmétique +, les opérateurs d’assignation =, les opérateurs de redirection <<).

De plus, il existe des opérateurs unaires (pré incrémentation ou post incrémentation), binaires (assignation, arithmétique) et ternaires (les ternaires n’étant pas surchargeables).

#pragma once 

#include <iostream>

class Integer
{
 public:
  Integer(int const n);
  ~Integer(void);

  int getValue(void) const;
  //Le mot clé operator permet d'indiquer qu'il s'agit d'une surcharge d'opérateur
  
  //Operateur d'assignation (binaire) - notation sous forme de fonction membre
  Integer &operator=(Integer const &rhs);//deux params (this, instance courante)
  Integer operator+(Integer const &rhs) const;

 private:
  int _n;
}
std::ostream &operator<<(std::ostream &o, Integer const &rhs);

// Nous devons retourner une reference sur l'instance courante pour permettre de chainer les assignations
// a = b = c = d;
Integer &Integer::operator=(Integer const &rhs)
{
 this->_n = rhs.getValue();
 return *this;//Une référence est toujours déréférencée
}

// Nous devons uniquement retourner une copie du résultat ici
Integer Integer::operator+(Integer const &rhs) const
{
 return Integer(this->_n + rhs.getValue());
}

// Autre opérateur binaire mais ni de classe ni d'instance
// surcharge de fonction 
// on retourne une reference sur ostream pour pouvoir effectuer des chaînages
std::ostream &operator<<(std::ostream &o, Integer const &rhs)
{
 o << rhs.getValue();
 return (o);
}

Il est plutôt recommandé d’éviter de réaliser des surcharges d’opérateurs, en particulier pour les débutants. Il existe de réels cas d’usage qui les rendent nécessaires, mais ils sont relativement limités.

Cette notion est cependant particulièrement pertinente pour écrire une classe de façon canonique.

Classe canonique

https://cdn.intra.42.fr/video/video/96/piscine_c___-_d02_-_02_caconical_form.mp4

Il est recommandé d’écrire ses classes de manière canonique. Il s’agit plutôt d’une bonne pratique / respect d’une convention plutôt que d’une nécessité technique.

#pragma once 

#include <iostream>

class Sample 
{
 public:
  Sample(void); // Constructeur par défaut (sans paramètre)
  Sample(Sample const &src); // Constructeur par copie (prenant une instance de la classe qu on est en train de déclarer)
  virtual ~Sample(void); // Destructeur par défaut (virtuel!)
  Sample &operator=(Sample const &rhs); //Opérateur d'assignation
}

Le mot clé virtual sera présenté dans un prochain module.