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 spécifier les types.

short, int, long, float, double, etc. sont tous des types de données numériques. Vous apprendrez à les connaître ainsi que les pièges qu'ils peuvent dissimuler.

Couvre le travail avec le texte en C++ en utilisant `char` et `string`. Vous apprendrez à stocker et manipuler des caractères, utiliser des méthodes de chaîne, indexer et modifier des chaînes, rechercher du texte et comprendre la gestion de la mémoire des chaînes. À la fin, vous serez prêt à gérer le texte efficacement dans vos programmes.

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

Opérations Arithmétiques

Définition de la précision

Solution