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. 

### Configuración de la precisión

Como ya deberías saber, puedes realizar manipulaciones básicas de datos utilizando operadores aritméticos como **suma** (`+`), **resta** (`-`), **división** (`/`) y **multiplicación** (`*`). Además, el **operador módulo** (`%`) calcula el resto de una división.

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8aW9tYW5pcD4KCmludCBtYWluKCkKewogICAgLy8gVW5jb21tZW50IHRvIHNlZSB0aGUgZGlmZmVyZW5jZQogICAgLy8gc3RkOjpjb3V0IDw8IHN0ZDo6Zml4ZWQ7CiAgICBzdGQ6OmNvdXQgPDwgc3RkOjpzZXRwcmVjaXNpb24oNSkgPDwgMTUuMTI1ICogMC44MzA5IDw8IHN0ZDo6ZW5kbDsKfQ==

En el ejemplo anterior, los resultados de punto flotante pueden producirse ocasionalmente durante los cálculos. Para gestionar la precisión de estos resultados, puedes utilizar `std::setprecision` en combinación con `std::fixed`. Esto permite controlar el número de dígitos que se muestran después del punto decimal, asegurando una precisión consistente en la salida.

Sin `std::fixed`, `std::setprecision` controla el número total de dígitos mostrados, incluyendo los anteriores y posteriores al punto decimal. Con `std::fixed`, el número se muestra en notación de punto fijo, manteniendo el punto decimal en una posición fija.

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

Desarrollar una comprensión integral de los tipos de datos es fundamental al aprender un lenguaje de programación. Este curso ofrece la oportunidad de profundizar en los tipos de datos en C++, obteniendo conocimientos sobre cómo se almacenan en la memoria. Además, el curso abarca el tema de la conversión de tipos.

Ofrece una visión general fundamental de las operaciones aritméticas y sus posibles errores, los tipos de datos y la importancia de especificar los tipos.

short, int, long, float, double, etc. son todos tipos de datos numéricos. Aprenderás sobre todos ellos, así como las posibles trampas que pueden ocultar.

Cubre el trabajo con texto en C++ utilizando `char` y `string`. Aprenderás cómo almacenar y manipular caracteres, usar métodos de cadena, indexar y modificar cadenas, buscar texto y comprender la gestión de memoria de las cadenas. Al final, estarás preparado para manejar texto de manera eficiente en tus programas.

Cubre valores lógicos con bool, funciones sin valores de retorno utilizando void y deducción automática de tipos con auto. También explora la conversión de tipos, incluyendo tanto la conversión implícita como la explícita, asegurando el manejo correcto de los tipos de datos.

Operaciones aritméticas

Configuración de la precisión

Solución