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

Explorez le monde des fonctions C++ et plongez dans leurs concepts fondamentaux et leurs applications pratiques. Acquérez des compétences dans la déclaration, l'utilisation et l'optimisation des fonctions, y compris la gestion des paramètres, la gestion de la portée et la surcharge de fonctions. Découvrez la récursion, les templates et les expressions lambda pour une programmation C++ robuste. Développez les compétences nécessaires pour créer des fonctions modulaires, efficaces et réutilisables pour relever des défis de codage concrets.

Il est maintenant temps de plonger dans le monde des fonctions C++ ! Vous allez maintenant apprendre quelques concepts généraux sur les fonctions en C++, y compris leur définition, déclaration et utilisation. Découvrez comment déclarer et appeler des fonctions, et obtenez des informations sur les portées des variables, à la fois locales et globales, pour une conception de programme efficace.

Nous allons approfondir la spécification et l'utilisation des arguments de fonction en programmation C++. Explorez des concepts tels que le passage par valeur et le passage par référence, et comprenez le rôle des arguments par défaut ; apprenez à passer des tableaux en tant qu'arguments de fonction et familiarisez-vous avec les arguments de fonction constants.

Nous allons maintenant apprendre à spécifier la valeur de retour d'une fonction en C++. Cela inclut la compréhension des types de données que les fonctions peuvent retourner, tels que les entiers, les nombres à virgule flottante et les tableaux. Nous examinerons également les fonctions qui n'ont pas de valeur de retour.

Maintenant, plongeons dans quelques sujets supplémentaires en C++ ! Nous explorerons la surcharge de fonctions, maîtrisant l'art de créer plusieurs fonctions avec le même nom mais des listes de paramètres différentes pour une flexibilité accrue du code. La récursivité est introduite, enseignant les principes des fonctions récursives, permettant aux étudiants de résoudre des problèmes complexes efficacement. De plus, la section couvre les fonctions lambda, fournissant des informations sur la création de fonctions anonymes concises.

Défi : Pratique de la Surcharge de Fonctions

Exemple

Solution

Awesome!

Défi : Pratique de la Surcharge de Fonctions

Exemple

Solution