Como Efetuar Operações de Arredondamento em C

Introdução

Neste laboratório, aprenderá a realizar operações de arredondamento em programação C. Começará declarando variáveis de ponto flutuante e, em seguida, explorará o uso de várias funções de arredondamento, como round(), floor(), e ceil(), para manipular os valores. Finalmente, imprimirá os resultados arredondados para observar os diferentes comportamentos de arredondamento.

Este laboratório abrange as habilidades fundamentais de operações aritméticas básicas em C, fornecendo uma base sólida para trabalhar com números de ponto flutuante e suas técnicas de arredondamento.

Declarar Variáveis de Ponto Flutuante

Neste passo, aprenderá a declarar e inicializar variáveis de ponto flutuante em C, essenciais para realizar operações de arredondamento.

Primeiro, crie um novo arquivo C para trabalhar com variáveis de ponto flutuante:

cd ~/project
nano rounding.c

Agora, adicione o seguinte código ao arquivo:

#include <stdio.h>

int main() {
    // Declarar variáveis de ponto flutuante
    float num1 = 3.7;
    double num2 = 4.2;

    // Imprimir os valores originais
    printf("Valor float original: %.1f\n", num1);
    printf("Valor double original: %.1f\n", num2);

    return 0;
}

Compile e execute o programa:

gcc rounding.c -o rounding
./rounding

Saída de exemplo:

Valor float original: 3.7
Valor double original: 4.2

Vamos analisar o código:

Usamos float para números de ponto flutuante de precisão simples.
Usamos double para números de ponto flutuante de precisão dupla.
O especificador de formato %.1f exibe o número com uma casa decimal.
num1 e num2 são inicializados com valores decimais.

Usar Funções (e.g., round, floor, ceil) para Arredondar Valores

Neste passo, aprenderá a usar funções de arredondamento em C para manipular números de ponto flutuante. Modificaremos o arquivo rounding.c anterior para demonstrar diferentes técnicas de arredondamento.

Abra o arquivo existente:

cd ~/project
nano rounding.c

Substitua o conteúdo anterior pelo seguinte código:

#include <stdio.h>
#include <math.h>

int main() {
    // Declarar variáveis de ponto flutuante
    float num1 = 3.7;
    double num2 = 4.2;

    // Arredondar valores usando diferentes funções
    printf("Valores originais:\n");
    printf("num1: %.1f, num2: %.1f\n\n", num1, num2);

    // Usando a função round()
    printf("Função round:\n");
    printf("round(num1): %.0f\n", round(num1));
    printf("round(num2): %.0f\n\n", round(num2));

    // Usando a função floor()
    printf("Função floor:\n");
    printf("floor(num1): %.0f\n", floor(num1));
    printf("floor(num2): %.0f\n\n", floor(num2));

    // Usando a função ceil()
    printf("Função ceil:\n");
    printf("ceil(num1): %.0f\n", ceil(num1));
    printf("ceil(num2): %.0f\n", ceil(num2));

    return 0;
}

Compile o programa com a biblioteca matemática:

gcc rounding.c -o rounding -lm
./rounding

Saída de exemplo:

Valores originais:
num1: 3.7, num2: 4.2

Função round:
round(num1): 4
round(num2): 4

Função floor:
floor(num1): 3
floor(num2): 4

Função ceil:
ceil(num1): 4
ceil(num2): 5

Pontos-chave sobre as funções de arredondamento:

round(): Arredonda para o inteiro mais próximo.
floor(): Arredonda para baixo para o inteiro mais próximo.
ceil(): Arredonda para cima para o inteiro mais próximo.
O sinal -lm é usado para vincular a biblioteca matemática durante a compilação.
O especificador de formato %.0f exibe inteiros sem casas decimais.

Imprimir Resultados Arredondados

Neste passo, aprenderá a formatar e imprimir resultados arredondados com diferentes níveis de precisão e opções de formatação.

Abra o arquivo existente:

cd ~/project
nano rounding.c

Atualize o código para demonstrar várias técnicas de impressão:

#include <stdio.h>
#include <math.h>

int main() {
    // Declarar variáveis de ponto flutuante
    float num1 = 3.7;
    double num2 = 4.2;

    // Demonstração de arredondamento com diferentes formatos de impressão
    printf("Demonstração de Arredondamento:\n");

    // Imprimir valores arredondados com diferentes precisões
    printf("1. Valores arredondados:\n");
    printf("   round(num1) = %.0f\n", round(num1));
    printf("   round(num2) = %.0f\n\n", round(num2));

    // Imprimir com largura de campo e precisão
    printf("2. Valores arredondados formatados:\n");
    printf("   num1 arredondado com largura: %5.1f\n", round(num1));
    printf("   num2 arredondado com largura: %5.1f\n\n", round(num2));

    // Imprimir representações inteira e de ponto flutuante
    printf("3. Representações inteira e de ponto flutuante:\n");
    printf("   num1 como inteiro: %d\n", (int)round(num1));
    printf("   num2 como inteiro: %d\n", (int)round(num2));

    return 0;
}

Compile e execute o programa:

gcc rounding.c -o rounding -lm
./rounding

Saída de exemplo:

Demonstração de Arredondamento:
1. Valores arredondados:
   round(num1) = 4
   round(num2) = 4

2. Valores arredondados formatados:
   num1 arredondado com largura:   4.0
   num2 arredondado com largura:   4.0

3. Representações inteira e de ponto flutuante:
   num1 como inteiro: 4
   num2 como inteiro: 4

Técnicas de impressão-chave:

%.0f: Remove casas decimais.
%5.1f: Define a largura do campo e a precisão.
Conversão de tipo com (int) converte para inteiro.
Diferentes especificadores de formato controlam a aparência da saída.

Resumo

Neste laboratório, aprendeu a declarar variáveis de ponto flutuante, incluindo float e double, e como usar várias funções de arredondamento, como round(), floor(), e ceil(), para manipular esses valores. Você imprimiu os valores originais e, em seguida, utilizou as funções de arredondamento para exibir os resultados arredondados. Isso permitiu que você compreendesse os diferentes comportamentos dessas funções e como elas podem ser aplicadas para arredondar números para cima, para baixo ou para o inteiro mais próximo.