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. 

### Impostazione della precisione

Come già dovresti sapere, è possibile eseguire manipolazioni di base sui dati utilizzando operatori aritmetici come **addizione** (`+`), **sottrazione** (`-`), **divisione** (`/`) e **moltiplicazione** (`*`). Inoltre, l'**operatore modulo** (`%`) calcola il resto di una divisione.

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8aW9tYW5pcD4KCmludCBtYWluKCkKewogICAgLy8gVW5jb21tZW50IHRvIHNlZSB0aGUgZGlmZmVyZW5jZQogICAgLy8gc3RkOjpjb3V0IDw8IHN0ZDo6Zml4ZWQ7CiAgICBzdGQ6OmNvdXQgPDwgc3RkOjpzZXRwcmVjaXNpb24oNSkgPDwgMTUuMTI1ICogMC44MzA5IDw8IHN0ZDo6ZW5kbDsKfQ==

Nell'esempio sopra, durante i calcoli possono talvolta essere prodotti risultati in virgola mobile. Per gestire la precisione di questi risultati, è possibile utilizzare `std::setprecision` in combinazione con `std::fixed`. Questo consente di controllare il numero di cifre visualizzate dopo il punto decimale, garantendo una precisione costante nell'output.

Senza `std::fixed`, `std::setprecision` controlla il numero totale di cifre visualizzate, includendo sia quelle prima che dopo il punto decimale. Con `std::fixed`, il numero viene visualizzato in notazione a virgola fissa, mantenendo il punto decimale in una posizione fissa.

Nota

#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

Sviluppare una comprensione approfondita dei tipi di dati è fondamentale nell'apprendimento di un linguaggio di programmazione. Questo corso offre l'opportunità di approfondire i tipi di dati in C++, acquisendo conoscenze su come vengono memorizzati in memoria. Inoltre, il corso tratta il tema della conversione dei tipi.

Fornisce una panoramica fondamentale delle operazioni aritmetiche e delle loro insidie, dei tipi di dati e dell'importanza della specifica dei tipi.

short, int, long, float, double, ecc. sono tutti tipi di dati numerici. Verranno illustrati tutti, insieme alle insidie che possono nascondere.

Tratta la gestione del testo in C++ utilizzando `char` e `string`. Verrà illustrato come memorizzare e manipolare caratteri, utilizzare i metodi delle stringhe, indicizzare e modificare le stringhe, cercare testo e comprendere la gestione della memoria delle stringhe. Al termine, sarai in grado di gestire il testo in modo efficiente nei tuoi programmi.

Tratta i valori logici con bool, le funzioni senza valori di ritorno utilizzando void e la deduzione automatica del tipo con auto. Esplora inoltre la conversione dei tipi, includendo sia il casting implicito che esplicito, garantendo una corretta gestione dei tipi di dati.

Operazioni Aritmetiche

Impostazione della precisione

Soluzione