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. 

### Definindo a precisão

Como já deve saber, é possível realizar manipulação básica de dados utilizando operadores aritméticos como **adição** (`+`), **subtração** (`-`), **divisão** (`/`) e **multiplicação** (`*`). Além disso, o **operador módulo** (`%`) calcula o resto de uma divisão.

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8aW9tYW5pcD4KCmludCBtYWluKCkKewogICAgLy8gVW5jb21tZW50IHRvIHNlZSB0aGUgZGlmZmVyZW5jZQogICAgLy8gc3RkOjpjb3V0IDw8IHN0ZDo6Zml4ZWQ7CiAgICBzdGQ6OmNvdXQgPDwgc3RkOjpzZXRwcmVjaXNpb24oNSkgPDwgMTUuMTI1ICogMC44MzA5IDw8IHN0ZDo6ZW5kbDsKfQ==

No exemplo acima, resultados em ponto flutuante podem ser gerados ocasionalmente durante os cálculos. Para gerenciar a precisão desses resultados, é possível utilizar `std::setprecision` em combinação com `std::fixed`. Isso permite controlar o número de dígitos exibidos após o ponto decimal, garantindo precisão consistente na saída.

Sem `std::fixed`, `std::setprecision` controla o número total de dígitos exibidos, incluindo os antes e depois do ponto decimal. Com `std::fixed`, o número é exibido em notação de ponto fixo, mantendo o ponto decimal em uma posição fixa.

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

Desenvolver uma compreensão abrangente dos tipos de dados é fundamental ao aprender uma linguagem de programação. Este curso oferece a oportunidade de aprofundar os tipos de dados em C++, proporcionando insights sobre como eles são armazenados na memória. Além disso, o curso aborda o tema da conversão de tipos.

Fornece uma visão geral fundamental sobre operações aritméticas e suas armadilhas, tipos de dados e a importância de especificar tipos.

short, int, long, float, double, etc. são todos tipos de dados numéricos. Você aprenderá sobre cada um deles, bem como sobre as armadilhas que podem ocultar.

Abrange o trabalho com texto em C++ utilizando `char` e `string`. Você aprenderá a armazenar e manipular caracteres, utilizar métodos de string, indexar e modificar strings, localizar texto e compreender o gerenciamento de memória de strings. Ao final, estará apto a lidar com texto de forma eficiente em seus programas.

Abrange valores lógicos com bool, funções sem valores de retorno utilizando void e dedução automática de tipo com auto. Também explora conversão de tipos, incluindo casting implícito e explícito, garantindo o tratamento correto dos tipos de dados.

Operações Aritméticas

Definindo a precisão

Solução