Summary  
This chapter explains how to use basic arithmetic operators (addition, subtraction, multiplication, division, modulus), highlights integer versus floating-point division behavior, and shows how to format floating-point results using fixed and setprecision when printing.

General domain of usage  
Numeric data processing

This video introduces arithmetic operations in C++, including addition, subtraction, multiplication, division, and the modulus operator. You will also learn how to control output precision using std::fixed and std::setprecision for floating-point calculations. Practical code examples demonstrate how to perform calculations and format results for clear, accurate output. By the end, you will understand both the basic operators and how to manage the display of numerical data in C++ programs. 

### Définition de la précision

Comme vous le savez déjà, il est possible d'effectuer des manipulations de données de base à l'aide des opérateurs arithmétiques tels que **addition** (`+`), **soustraction** (`-`), **division** (`/`) et **multiplication** (`*`). De plus, l'**opérateur de modulo** (`%`) calcule le reste d'une division.

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8aW9tYW5pcD4KCmludCBtYWluKCkKewogICAgLy8gVW5jb21tZW50IHRvIHNlZSB0aGUgZGlmZmVyZW5jZQogICAgLy8gc3RkOjpjb3V0IDw8IHN0ZDo6Zml4ZWQ7CiAgICBzdGQ6OmNvdXQgPDwgc3RkOjpzZXRwcmVjaXNpb24oNSkgPDwgMTUuMTI1ICogMC44MzA5IDw8IHN0ZDo6ZW5kbDsKfQ==

Dans l'exemple ci-dessus, des résultats à virgule flottante peuvent parfois être produits lors des calculs. Pour gérer la précision de ces résultats, il est possible d'utiliser `std::setprecision` en combinaison avec `std::fixed`. Cela permet de contrôler le nombre de chiffres affichés après la virgule, garantissant ainsi une précision constante dans l'affichage des résultats.

Sans `std::fixed`, `std::setprecision` contrôle le nombre total de chiffres affichés, y compris avant et après la virgule décimale. Avec `std::fixed`, le nombre est affiché en notation à virgule fixe, maintenant la virgule décimale à une position fixe.

Remarque

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>

double convertToEuro(double dollars);

TEST_CASE("Convert 50 USD to 47.00 EUR", "[convertToEuro]") {
    REQUIRE(convertToEuro(50.0) == Approx(47.00).margin(0.001));
}

TEST_CASE("Convert 100.5 USD to 94.47 EUR", "[convertToEuro]") {
    REQUIRE(convertToEuro(100.5) == Approx(94.47).margin(0.001));
}

TEST_CASE("Convert 0 USD to 0.00 EUR", "[convertToEuro]") {
    REQUIRE(convertToEuro(0.0) == Approx(0.00).margin(0.001));
}

TEST_CASE("Convert 1.234 USD to 1.16 EUR", "[convertToEuro]") {
    REQUIRE(convertToEuro(1.234) == Approx(1.16).margin(0.001));
}

TEST_CASE("Uses std::setprecision", "[code check]") {
    std::ifstream file(__FILE__);
    std::string code((std::istreambuf_iterator<char>(file)),
                     std::istreambuf_iterator<char>());

    REQUIRE(code.find("setprecision") != std::string::npos);
}

TEST_CASE("Uses std::fixed", "[code check]") {
    std::ifstream file(__FILE__);
    std::string code((std::istreambuf_iterator<char>(file)),
                     std::istreambuf_iterator<char>());

    REQUIRE(code.find("fixed") != std::string::npos);
}

test.cpp

Développer une compréhension approfondie des types de données est essentiel lors de l'apprentissage d'un langage de programmation. Ce cours offre l'opportunité d'explorer en détail les types de données en C++, en acquérant des connaissances sur leur stockage en mémoire. De plus, le cours aborde la conversion de types.

Fournit une vue d'ensemble fondamentale des opérations arithmétiques et de leurs pièges, des types de données et de l'importance de la spécification des types.

short, int, long, float, double, etc. sont tous des types de données numériques. Vous découvrirez chacun d'eux ainsi que les pièges qu'ils peuvent dissimuler.

Traite de la gestion du texte en C++ à l'aide de `char` et `string`. Présente les méthodes de stockage et de manipulation des caractères, l'utilisation des méthodes de chaîne, l'indexation et la modification des chaînes, la recherche de texte, ainsi que la gestion de la mémoire des chaînes. À l'issue de ce module, vous serez prêt à gérer efficacement le texte dans vos programmes.

Couvre les valeurs logiques avec bool, les fonctions sans valeur de retour utilisant void, et la déduction automatique du type avec auto. Explore également la conversion de type, y compris le transtypage implicite et explicite, afin d'assurer une gestion correcte des types de données.

Opérations Arithmétiques

Définition de la précision

Solution