Variáveis e tipos básicos

#include <stdio.h>

int main(void)
{
    /* Cada informação fica numa variável do tipo adequado */
    int porcoes = 6;
    double polvilho_kg = 0.5;
    int tempo_min = 25;
    int temperatura = 180;
    char dificuldade = 'B';

    puts("Receita: Pão de queijo");
    printf("Porções: %d\n", porcoes);
    printf("Polvilho (kg): %.2f\n", polvilho_kg);      /* duas casas */
    printf("Tempo de forno (min): %d\n", tempo_min);
    printf("Temperatura: %d graus\n", temperatura);
    printf("Dificuldade: %c\n", dificuldade);          /* %c para char */
    return 0;
}

Passo a passo

1. As cinco variáveis são declaradas no início de main, cada uma com tipo, nome e valor inicial; declarar e inicializar na mesma linha evita usar uma variável com lixo de memória.
2. Porções, tempo e temperatura são contagens sem parte decimal, por isso usam int.
3. A quantidade de polvilho tem parte decimal, então fica em double, o tipo de ponto flutuante padrão em C.
4. A dificuldade é uma única letra: char com o valor entre aspas simples ('B').
5. O título não depende de variável, então puts basta; as demais linhas usam printf com o especificador que combina com o tipo: %d para int, %.2f para double e %c para char.
6. %.2f mostra 0.5 como 0.50, com as duas casas pedidas na saída.

Por que funciona

Uma variável é um espaço na memória com nome e tipo. O tipo diz ao compilador quanto espaço reservar e como interpretar os bits, e diz a você qual especificador usar no printf. Escolhendo o tipo certo para cada dado, os valores saem exatamente como foram guardados.

Erros comuns

• Aspas duplas no char: char dificuldade = "B"; tenta guardar o endereço de uma string num char; o GCC avisa e a saída sai errada. Use 'B'.
• Especificador trocado: printf("Polvilho (kg): %d\n", polvilho_kg); passa um double para %d, comportamento indefinido que costuma imprimir lixo. Use %f (aqui %.2f).
• Guardar 0.5 num int: int polvilho_kg = 0.5; descarta a parte decimal e a variável vale 0. Use double.
• Usar a variável sem inicializar: int porcoes; printf("%d", porcoes); imprime um valor imprevisível. Sempre dê um valor antes de ler.

Outra forma de resolver

Dá para declarar várias variáveis do mesmo tipo numa linha só:

int porcoes = 6, tempo_min = 25, temperatura = 180;

É compacto e útil para valores relacionados, mas uma declaração por linha facilita comentar e encontrar cada variável.

Saída esperada

Receita: Pão de queijo
Porções: 6
Polvilho (kg): 0.50
Tempo de forno (min): 25
Temperatura: 180 graus
Dificuldade: B

#include <stdio.h>

int main(void)
{
    int nota1 = 7;
    int nota2 = 8;
    int nota3 = 10;
    int soma = nota1 + nota2 + nota3;

    /* int / int: a parte decimal é descartada */
    int media_inteira = soma / 3;

    /* O cast converte soma para double ANTES da divisão */
    double media_real = (double)soma / 3;

    puts("Boletim de Rafa");
    printf("Soma das notas: %d\n", soma);
    printf("Média (divisão inteira): %d\n", media_inteira);
    printf("Média (com cast): %.2f\n", media_real);
    return 0;
}

Passo a passo

1. As três notas são inteiras, então ficam em variáveis int; a soma de inteiros também é int e vale 25.
2. soma / 3 divide dois inteiros: o C faz divisão inteira e descarta a parte decimal, resultando em 8.
3. (double)soma é um cast: converte o valor de soma para double só nessa expressão, sem mudar a variável.
4. Como um dos operandos agora é double, o 3 também é convertido e a divisão dá 8.333....
5. %d imprime a média inteira e %.2f arredonda a média real para 8.33.
6. O título não tem valores, então usa puts.

Por que funciona

O tipo do resultado de uma operação depende dos tipos dos operandos. Entre dois int, a divisão é inteira; se pelo menos um for double, o outro é promovido e a conta é feita em ponto flutuante. O cast é a forma explícita de dizer ao compilador "trate este valor como double aqui".

Erros comuns

• Guardar em double sem converter: double media_real = soma / 3; ainda dá 8.00, porque a divisão inteira acontece antes da atribuição. Converta um operando: (double)soma / 3.
• Cast no lugar errado: (double)(soma / 3) converte o resultado já truncado e também dá 8.00. O cast precisa vir antes da divisão.
• %d com double: printf("%d\n", media_real); é comportamento indefinido e imprime lixo; o -Wall avisa. Use %f.

Outra forma de resolver

Em vez do cast, use uma constante double no divisor:

double media_real = soma / 3.0;

Funciona porque 3.0 já é double. O cast é preferível quando o divisor também é uma variável int, como (double)soma / quantidade.

Saída esperada

Boletim de Rafa
Soma das notas: 25
Média (divisão inteira): 8
Média (com cast): 8.33

#include <stdio.h>

int main(void)
{
    /* Constantes com nome no lugar de números mágicos */
    const int SEGUNDOS_POR_MINUTO = 60;
    const int SEGUNDOS_POR_HORA = 3600;

    int total = 9876;

    /* Divisão inteira dá as horas cheias; % dá o que sobra */
    int horas = total / SEGUNDOS_POR_HORA;
    int resto = total % SEGUNDOS_POR_HORA;
    int minutos = resto / SEGUNDOS_POR_MINUTO;
    int segundos = resto % SEGUNDOS_POR_MINUTO;

    int minutos_completos = total / SEGUNDOS_POR_MINUTO;

    /* Cast para manter a parte decimal das horas */
    double horas_decimais = (double)total / SEGUNDOS_POR_HORA;

    printf("Tempo total: %d s\n", total);
    printf("Formatado: %02d:%02d:%02d\n", horas, minutos, segundos);
    printf("Minutos completos: %d\n", minutos_completos);
    printf("Em horas: %.2f h\n", horas_decimais);
    return 0;
}

Passo a passo

1. const int cria valores que não podem ser alterados depois; nomear 60 e 3600 deixa claro o que cada conta faz e o compilador recusa uma atribuição acidental.
2. total / SEGUNDOS_POR_HORA é divisão inteira: 9876 / 3600 dá 2 horas cheias.
3. total % SEGUNDOS_POR_HORA devolve o resto, 2676 segundos que não completam uma hora.
4. O mesmo par / e % aplicado ao resto separa 44 minutos e 36 segundos.
5. total / SEGUNDOS_POR_MINUTO dá os minutos completos do tempo todo: 164.
6. (double)total / SEGUNDOS_POR_HORA converte antes de dividir, então o resultado é 2.7433..., mostrado como 2.74 por %.2f.
7. %02d imprime o inteiro com pelo menos 2 dígitos, completando com zero à esquerda: 2 vira 02.

Por que funciona

Aqui a divisão inteira, que costuma ser armadilha, é exatamente o que se quer: / entre inteiros dá a quantidade de unidades cheias e % dá a sobra. Encadeando os dois, de horas para minutos e de minutos para segundos, o total se decompõe sem perder nenhum segundo (2 × 3600 + 44 × 60 + 36 = 9876).

Quando a parte decimal importa, como nas horas em formato decimal, o cast para double muda o tipo da conta. A mesma variável int serve aos dois casos; o que decide o resultado é o tipo dos operandos em cada expressão.

Erros comuns

• Calcular os minutos a partir do total: int minutos = total / SEGUNDOS_POR_MINUTO; dá 164, não 44, porque inclui os minutos das horas já contadas. Use o resto: resto / SEGUNDOS_POR_MINUTO.
• Esquecer o 0 em %02d: %2d completa com espaço e a saída fica 2:44:36. O 0 é o que preenche com zeros.
• Dividir sem cast: double horas_decimais = total / SEGUNDOS_POR_HORA; faz divisão inteira e mostra 2.00. Converta um operando antes.
• Tentar alterar a constante: SEGUNDOS_POR_HORA = 60; não compila (assignment of read-only variable). Se o valor muda, ele não deveria ser const.

Outra forma de resolver

As constantes também podem ser macros do pré-processador:

#define SEGUNDOS_POR_MINUTO 60
#define SEGUNDOS_POR_HORA 3600

O #define troca o nome pelo valor antes da compilação e era o estilo clássico em C; ele é preferível quando o valor precisa ser uma constante em tempo de compilação, como o tamanho de um vetor global. Para contas como estas, const int tem tipo e respeita escopo.

Saída esperada

Tempo total: 9876 s
Formatado: 02:44:36
Minutos completos: 164
Em horas: 2.74 h