Polymorphisme

Qu'est-ce que c'est ?

Le polymorphisme est une méthode de développement en C++, permettant de surcharger des méthodes, des opérateurs, apporter de la généricité ou encore de disposer de méthodes virtuelles.

Surcharge de méthodes

La surcharge de méthode est un élément important dans ce langage de programmation. Le principe, c'est de disposer de plusieurs méthodes dans une classe, avec des signatures différentes. Ainsi, vous pourriez très bien vouloir disposer d'une méthode permettant de réaliser une addition entre deux chiffres de type int et une autre pour des float.

Pour illustrer cela, créons nos deux fonctions d'additions :

int addition(int number1, int number2)
{
    return number1+number2;
}

float addition(float number1, float number2)
{
    return number1+number2;
}

La première requiert des integer et renvoi un integer, quand la seconde demande des float et renvoi un float. Quand vous allez vouloir utiliser la méthode, votre IDE vous indiquera les deux possibilités, et choisira en fonction du type de paramètre fournis.

Surcharge d'opérateur

La surcharge d'opérateur, consiste à réécrire les différents opérateurs (+, +=, etc.) qui existent en C++. Cela permet de disposer d'un comportement spécifique. Par exemple, imaginons que l'on souhaite additionner deux sf::Vector2f de la librairie SFML. nous aurions dans notre classe la méthode suivante :

sf::Vector2f operator+(const sf::Vector2f& a, const sf::Vector2f& b)
{
    return sf::Vector2f(a.x + b.x, a.y + b.y);
}

Ainsi, quand vous allez vouloir dans votre code faire :

sf::Vector2f a = {3.0f, 4.0f}
sf::Vector2f b = {5.0f, 1.0f}
sf::Vector2f c;

c = a + b;

Vous allez avoir x = 8.0 et y = 5.0. En effet, dans votre classe vous avez créé une méthode "+" (en gros). C'est un opérateur, donc quand vous faites appel au + pour faire votre addition, il va utiliser la méthode operator+.

Généricité

La généricité est le principe d'utiliser les template afin d'éviter de définir plusieurs méthodes pour une même action. Si on reprend comme exemple notre surcharge de méthode pour réaliser notre addition. Avec les templates, on peut disposer que d'une seule et unique méthode :

template<typename T> addition(const T& a, const T& b)
{
    return a + b;
}

Ainsi, nous n'avons plus qu'une seule et unique méthode pour faire notre addition, et elle prend en compte automatiquement notre exemple aussi sur la surcharge d'opérateur. En effet, si on reprend l'exemple précédent, l'opérateur + est utilisable pour additionner nos vecteurs.

Polymorphisme d'héritage

Le polymorphisme d'héritage repose sur des classes héritant d'une autre avec des méthodes dites virtuelles. Les méthodes virtuelles, sont des méthodes qui n'ont pas d'implémentations et sont là, afin d'être implémentée dans les classes sous-jacentes.

Les méthodes virtuelles peuvent être de deux types :

virtuelle
Virtuelle pure

Méthode virtuelle

Les méthodes virtuelles se déclarent avec le mot-clé virtual en début de signature. Une méthode virtuelle non redéfinie (mot-clé override en fin de signature de la méthode redéfinie), utilisera l'implémentation de sa classe parente.

Méthode virtuelle pure

Les méthodes virtuelles pure, se déclarent et se redéfinissent de la même façon. La différence se situant dans le fait qu'à la fin de la signature de la méthode virtuelle pure, il faut ajouter : = 0.

Le fait de définir une méthode comme étant virtuelle pure, suffit à rendre la classe abstraite, c'est-à-dire qu'elle ne peut être instanciée.

La virtuelle pure, ne dispose qu'aucune implémentation dans sa classe de base, à l'inverse de la virtuelle, dont une implémentation de base peut exister.

Conclusion

Le polymorphisme permet beaucoup de chose, mais il y a de quoi s'y perdre. Les erreurs avec les méthodes virtuelles et virtuelles pure sont si vite arrivée, et vous pouvez m'en croire : j'ai failli perdre la tête sur mon projet.

Une fois que vous arrivez à maîtriser ce concept, vous êtes parer pour à peu près tous les projets possible.

26 février 2025