Fácil C

Criando uma macro para o dobro

Enunciado

Escreva um programa que defina uma macro DOBRO(x) que retorna o dobro de um número. Use essa macro para calcular e imprimir o dobro de 5 e de 3.5.

Requisitos

  • Definir a macro DOBRO(x) usando #define.
  • A macro deve funcionar para inteiros e floats.
  • Imprimir os resultados com printf.

Código inicial

#include <stdio.h>

// Defina a macro DOBRO aqui

int main(void) {
    // Use a macro e imprima
    return 0;
}

Saída esperada

Dobro de 5: 10
Dobro de 3.5: 7.00
Ver dica

Não esqueça dos parênteses ao redor do parâmetro na definição da macro: #define DOBRO(x) (2 * (x)).

Mostrar solução 
#include <stdio.h>

// Macro que calcula o dobro
#define DOBRO(x) (2 * (x))

int main(void) {
    int a = 5;
    double b = 3.5;

    // Usando a macro com int e double
    printf("Dobro de 5: %d\n", DOBRO(a));
    printf("Dobro de 3.5: %.2f\n", DOBRO(b));

    return 0;
}

Passo a passo

  1. Incluímos <stdio.h> para usar printf.
  2. Definimos a macro DOBRO(x) como (2 * (x)). Os parênteses garantem que a expressão seja avaliada corretamente mesmo se x for uma expressão complexa.
  3. No main, declaramos a como inteiro e b como double.
  4. Chamamos DOBRO(a) e DOBRO(b) dentro do printf. O pré-processador substitui DOBRO(a) por (2 * (a)) e DOBRO(b) por (2 * (b)).
  5. Os formatos %d e %.2f imprimem os valores corretos.

Por que funciona

A macro é expandida textualmente antes da compilação. Como usamos parênteses ao redor do parâmetro e da expressão, a precedência de operadores é preservada. Isso permite que a mesma macro funcione para diferentes tipos numéricos, pois a substituição é feita antes da verificação de tipos.

Erros comuns

  • Esquecer os parênteses: #define DOBRO(x) 2 * x. Se usarmos DOBRO(3+4), o resultado será 2 * 3 + 4 = 10, não 14. Corrija com (2 * (x)).
  • Usar ponto e vírgula na definição: #define DOBRO(x) (2 * (x)); Isso inclui o ponto e vírgula na substituição, causando erros de sintaxe em contextos como int y = DOBRO(5);.
  • Confundir macro com função: macros não têm tipo de retorno nem verificam argumentos. Cuidado com efeitos colaterais, como DOBRO(i++).

Outra forma de resolver

Se preferir segurança de tipos, use uma função inline:

static inline int dobro_int(int x) { return 2 * x; }
static inline double dobro_double(double x) { return 2 * x; }

Mas isso exige duas funções para tipos diferentes. A macro é mais genérica.

Saída esperada

Dobro de 5: 10
Dobro de 3.5: 7.00