Summary  
This chapter demonstrates how to implement function overloading by defining multiple functions with the same name but different parameter types or counts to achieve compile-time polymorphism and cleaner code.  

General domain of usage  
Mathematical computation libraries

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <cmath>

const double PI = 3.14159;

// Function declarations (to be linked with actual implementation)
double calculateArea(double length, double width);
double calculateArea(double radius);
double calculateArea(double a, double b, double c);

TEST_CASE("Circle area with radius 3 should be ~28.27431", "[calculateArea]") {
    double result = calculateArea(3.0);
    REQUIRE(result == Approx(PI * 3 * 3)); // Area = PI * r^2
}

TEST_CASE("Rectangle area 4 x 6 should be 24", "[calculateArea]") {
    double result = calculateArea(4.0, 6.0);
    REQUIRE(result == Approx(24.0)); // Area = length * width
}

TEST_CASE("Triangle area with sides 5, 4, 6 should be ~9.92157", "[calculateArea]") {
    double result = calculateArea(5.0, 4.0, 6.0);
    double s = (5 + 4 + 6) / 2.0;
    double expected = sqrt(s * (s - 5) * (s - 4) * (s - 6));
    REQUIRE(result == Approx(expected)); // Heron's formula
}

// Additional tests for coverage
TEST_CASE("Circle area with radius 0 should be 0", "[calculateArea]") {
    double result = calculateArea(0.0);
    REQUIRE(result == Approx(0.0)); // Area = 0 for radius 0
}

TEST_CASE("Rectangle area with 0 x 10 should be 0", "[calculateArea]") {
    double result = calculateArea(0.0, 10.0);
    REQUIRE(result == Approx(0.0)); // Area = 0 if any side is 0
}

TEST_CASE("Triangle area with sides 3, 4, 5 should be 6", "[calculateArea]") {
    double result = calculateArea(3.0, 4.0, 5.0);
    REQUIRE(result == Approx(6.0)); // Classic 3-4-5 triangle
}

TEST_CASE("Triangle area with invalid sides should be 0 or NaN", "[calculateArea]") {
    double result = calculateArea(1.0, 2.0, 10.0); // Impossible triangle
    if (!std::isnan(result)) {
        REQUIRE(result == Approx(0.0)); // If not NaN, should be 0
    }
}

test.cpp

Maîtrisez les principes fondamentaux des fonctions et leurs applications pratiques. Apprenez à déclarer, utiliser et optimiser les fonctions à travers des sujets tels que la gestion des paramètres, la gestion de la portée et la surcharge. Explorez la récursivité, les templates et les expressions lambda pour concevoir un code modulaire, efficace et réutilisable adapté aux défis réels.

Apprenez les concepts fondamentaux des fonctions, leur objectif, leur création et leur utilisation, ainsi que la manière dont les portées des variables influencent la logique du programme.

Apprenez à transmettre des données aux fonctions en utilisant des arguments par valeur, par référence et par pointeur. Comprenez les paramètres par défaut et constants, ainsi que la gestion des tableaux et des structures personnalisées.

Découvrez comment retourner des données depuis des fonctions en utilisant des types simples, des tableaux ou des types personnalisés. Comprenez quand utiliser le type void pour les fonctions sans valeur de retour.

Perfectionnez vos compétences en fonctions avec la surcharge, la récursivité et les fonctions lambda pour créer un code plus flexible, efficace et moderne.

Challenge: Exercice de Surcharge de Fonctions

Exemple

Solution