Introduction

Dans ce module, on va surtout passer du temps à comprendre ce qu’est un entier, un flottant, un nombre en virgule fixe/flottante, etc. Il y a également une nouvelle consigne à prendre en compte pour la suite des modules : nos classes devront se conformer à la forme canonique de Coplien. Nous allons commencer par comprendre ce qu’est la surcharge de fonctions (ou Polymorphisme ad-hoc).

Surcharge de fonctions

void	foo(int a) {
	cout << "int" << endl;
}

void	foo(float a) {
	cout << "float" << endl;
}

void	foo(double a) {
	cout << "double" << endl;
}

La forme canonique de Coplien

À partir de maintenant, vos classes devront impérativement se conformer à la forme canonique de Coplien, sauf en cas d’indication contraire. Cela signifie qu’elles devront comporter les quatre fonctions membres suivantes :

• Constructeur par défaut
• Constructeur de copie
• Opérateur d’affectation
• Destructeur

#ifndef SAMPLE_HPP
# define SAMPLE_HPP

#include <iostream>

class Sample {

public:
	Sample(void);							              // ✅ Constructeur par défaut 
	Sample(const int n);					          // 🆗 Bonne pratique ce constructeur
	Sample(const Sample &rhs);				      // ✅ Constructeur de recopie
	Sample & operator=(const Sample &rhs);	// ✅ Opérateur d’affectation
	~Sample(void);							            // ✅ Destructeur

	const int	getFoo(void);// 🆗 Bonne pratique cet accesseur

private:
	int	foo_;// 🆗 Bonne pratique le _

};

// 🆗 Bonne pratique
std::operator	&operator<<(std::ostream &o, const Sample &i);

#endif

Sample::Sample(const Sample &rhs) {
	std::cout << "Copy constructor called" << std::endl;
	*this = rhs;
	return ;
}

Sample	&Sample::operator=(const Sample &rhs) {
	std::cout << "Assignation operator called" << std::endl;
	this->foo_ = rhs.getFoo();
	return (*this);
}

std::operator	&operator<<(std::ostream &o, const Sample &i) {
	o << i.getFoo();
	return (o);
}

Qu'est-ce qu'un nombre

42 est un nombre écrit en base 10 (dite décimale). J’ai pioché dans une liste de chiffre allant de 0 à 9.

Le premier nombre que je peux écrire en utilisant les chiffres de ma base décimale, c’est : 0.

Le deuxième est 1, puis 2, jusqu'à 9 pour ensuite passer à 10.

Il faut imaginer que les chiffres du nombre 10 sont mis dans des cases : [1][0].

Si je veux augmenter ce nombre, je vais à la case la plus à droite et je lui donne le chiffre suivant dans ma liste {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.

[1][0] -> [1][1] -> [1][2] -> [1][3] -> [1][4] -> ... -> [1][9] -> ?