Docs executáveis de C: Conversão de tipos

Q: Como se faz um cast em C?

Coloque o tipo de destino entre parênteses antes do valor: (double)x, (int)3.9, (char)65. O cast se aplica à expressão imediatamente seguinte, então (double)a / b converte a primeiro e depois divide, enquanto (double)(a / b) divide como inteiros e converte o resultado.

Q: Como converter um int em float em C?

A atribuição faz isso implicitamente - double d = 5; guarda 5.0. Dentro de uma expressão você muitas vezes precisa de um cast explícito: (double)total / count força a divisão em ponto flutuante em vez da divisão inteira.

O C converte valores entre tipos o tempo todo. Algumas dessas conversões você escreve com um cast; a maioria o compilador realiza em silêncio, sob regras que você não escolheu. Saber qual é qual é a diferença entre "por que a minha média sempre dá 3?" e um código que faz o que diz.

Conversão implícita

Sempre que um valor de um tipo encontra um contexto que espera outro, o C converte:

#include <stdio.h>

int main(void) {
    int    i = 5;
    double d = i;        /* int -> double: 5.0, exato */
    char   c = 'A';
    int    code = c;     /* char -> int: 65 */
    double pi = 3.9;
    int    truncated = pi;   /* double -> int: 3, o .9 sumiu */

    printf("d         = %f\n", d);
    printf("code      = %d\n", code);
    printf("truncated = %d\n", truncated);
    return 0;
}

Conversões que não podem perder informação (int para double, char para int, short para long) são alargamentos e são sempre seguras. Conversões na direção contrária são estreitamentos e podem perder dados - o 3.9 acima virou 3 sem nenhum aviso, a menos que você peça um com -Wconversion.

As conversões aritméticas usuais

Quando um operador binário tem operandos de tipos diferentes, o C os converte para um tipo comum antes de fazer o trabalho. A escada, de baixo para cima:

Qualquer coisa menor que int (char, short, _Bool) é promovida a int. Isso é a promoção de inteiros e acontece primeiro, sempre.
Se um dos lados for long double, o outro vira long double.
Senão, se um for double, o outro vira double.
Senão, se um for float, o outro vira float.
Senão, entre tipos inteiros, o de maior posto vence, e se os postos empatarem, o sem sinal vence.

Essa última regra é a que causa bugs de verdade. O resto é intuitivo.

#include <stdio.h>

int main(void) {
    char a = 100, b = 100;

    /* a e b sao promovidos a int primeiro, entao 10000 cabe sem problema. */
    printf("a * b como int = %d\n", a * b);

    /* Mas guardar de volta num char estreita de novo. */
    char product = a * b;
    printf("guardado em char = %d\n", product);
    return 0;
}

A promoção de inteiros é a razão de a aritmética com char não transbordar do jeito que você poderia esperar - e de guardar o resultado de volta num char transbordar.

Casts explícitos

Um cast é o tipo de destino entre parênteses:

(double)x
(int)3.9
(char)65
(unsigned int)n

Ele se aplica à expressão imediatamente seguinte, e liga muito forte - mais forte que *, / ou +.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("sem cast:       %f\n", (double)(total / count));  /* 3.0 */
    printf("cast antes:     %f\n", (double)total / count);    /* 3.5 */
    printf("cast nos dois:  %f\n", (double)total / (double)count);
    return 0;
}

A primeira linha divide como inteiros (dando 3) e depois converte 3 para 3.0 - tarde demais. A segunda converte total antes da divisão, então o operador / vê um double e um int, promove o int e realiza divisão em ponto flutuante.

Converter um dos operandos basta. As conversões aritméticas usuais cuidam do outro.

Corrigindo a divisão inteira

Essa é, de longe, a razão mais comum para escrever um cast em C:

#include <stdio.h>

int main(void) {
    int scores[] = {88, 92, 75, 61, 90};
    int n = 5;
    int sum = 0;

    for (int i = 0; i < n; i++) {
        sum += scores[i];
    }

    printf("soma = %d\n", sum);
    printf("media errada: %f\n", (double)(sum / n));    /* 81.000000 - dividido como inteiros e SO ENTAO convertido */
    printf("media certa:  %f\n", (double)sum / n);      /* 81.200000 */

    /* Porcentagens tem a mesma armadilha. */
    int passed = 3;
    printf("pct errada: %d%%\n", passed / n * 100);            /* 0 por cento */
    printf("pct certa:  %.1f%%\n", 100.0 * passed / n);        /* 60.0 por cento */
    return 0;
}

A linha da porcentagem é instrutiva: passed / n é 3 / 5, que dá 0 como inteiros, e 0 * 100 é 0. Multiplicar antes de dividir (100 * passed / n) corrige isso mesmo sem um cast, porque 300 / 5 é exato - mas isso só funciona quando os números colaboram. O cast é a correção confiável.

Truncamento, não arredondamento

Converter um valor de ponto flutuante para inteiro descarta a fração. Ele trunca em direção a zero - não arredonda:

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

int main(void) {
    printf("(int) 3.2  = %d\n", (int) 3.2);
    printf("(int) 3.9  = %d\n", (int) 3.9);    /* 3, nao 4 */
    printf("(int)-3.9  = %d\n", (int)-3.9);    /* -3, nao -4 */

    /* Arredondamento de verdade, de math.h: */
    printf("round(3.9)  = %d\n", (int)round(3.9));    /* 4  */
    printf("round(-3.9) = %d\n", (int)round(-3.9));   /* -4 */
    printf("floor(3.9)  = %d\n", (int)floor(3.9));    /* 3  */
    printf("ceil(3.2)   = %d\n", (int)ceil(3.2));     /* 4  */
    return 0;
}

Se você compilar isso na sua própria máquina, lembre-se de que math.h precisa de -lm na ligação no Linux.

Mais um perigo: converter um valor de ponto flutuante grande demais para o tipo inteiro é comportamento indefinido, e não um giro. (int)1e20 pode produzir qualquer coisa. Confira o intervalo antes do cast quando o valor não estiver sob o seu controle.

char e int

Um char em C é um inteiro pequeno guardando um código de caractere. Converter entre os dois é trabalho do dia a dia:

#include <stdio.h>

int main(void) {
    char letter = 'A';
    int code = letter;

    printf("'%c' tem codigo %d\n", letter, code);
    printf("code + 1 e '%c'\n", (char)(code + 1));   /* 'B' */

    /* Caractere de digito para o seu valor numerico: */
    char digit = '7';
    int value = digit - '0';
    printf("o caractere '%c' como numero e %d\n", digit, value);

    /* Maiuscula para minuscula, usando o intervalo fixo de 32 posicoes no ASCII: */
    for (char ch = 'A'; ch <= 'E'; ch++) {
        printf("%c -> %c\n", ch, (char)(ch + 32));
    }
    return 0;
}

digit - '0' é o idioma padrão para transformar um caractere de dígito no seu valor, e funciona porque os dez caracteres de dígito têm garantia de serem consecutivos. Para letras, prefira toupper() e tolower() de ctype.h à aritmética do + 32 - o deslocamento é um fato do ASCII, não uma garantia do C.

Uma armadilha relacionada: funções de ctype.h como isdigit e toupper recebem um int que precisa ser EOF ou representável como unsigned char. Passar um char puro que seja negativo (possível, já que char puro pode ter sinal) é indefinido. Converta: isdigit((unsigned char)c).

A armadilha signed/unsigned

O passo 5 da escada de conversões - o sem sinal vence o empate - produz a comparação mais surpreendente do C:

#include <stdio.h>

int main(void) {
    int          signed_val = -1;
    unsigned int unsigned_val = 1;

    if (signed_val < unsigned_val) {
        printf("-1 e menor que 1  (o que voce espera)\n");
    } else {
        printf("-1 NAO e menor que 1  (o que o C realmente diz)\n");
    }

    printf("(unsigned)-1 = %u\n", (unsigned int)signed_val);
    return 0;
}

-1 é convertido para unsigned int, o que reinterpreta o seu padrão de bits como 4.294.967.295. Isso é maior que 1, então a comparação é falsa.

A mesma conversão faz laços rodarem para sempre:

/* BUG: i e sem sinal, entao i >= 0 e sempre verdadeiro. Quando i e 0, i-- da a volta. */
for (size_t i = n - 1; i >= 0; i--) { ... }

E faz verificações de comprimento falharem:

/* BUG: strlen devolve size_t (sem sinal). Se a string tiver menos de 5,
   len - 5 da a volta para um numero enorme e o teste passa. */
if (strlen(s) - 5 > 0) { ... }

Reescreva como if (strlen(s) > 5) e a subtração nunca acontece.

As defesas: mantenha contagens e índices com a mesma sinalização do começo ao fim, compile com -Wsign-compare (incluído em -Wextra) e, quando precisar misturar, converta explicitamente depois de estabelecer que o valor não pode ser negativo.

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *s = "oi";
    size_t len = strlen(s);

    /* Seguro: compare sem subtrair. */
    if (len > 5) {
        printf("longa\n");
    } else {
        printf("curta: %zu caracteres\n", len);
    }

    /* Seguro: converta para um tipo com sinal quando o valor e sabidamente pequeno. */
    int signed_len = (int)len;
    printf("len - 5 = %d\n", signed_len - 5);
    return 0;
}

Convertendo ponteiros

Casts também convertem entre tipos de ponteiro, e aí eles carregam risco real porque mudam como a memória é interpretada, não os bytes em si.

#include <stdio.h>

int main(void) {
    int value = 1;
    /* Enxergar os bytes de um int atraves de um ponteiro para char. */
    unsigned char *bytes = (unsigned char *)&value;

    printf("o int 1 e armazenado como os bytes:");
    for (size_t i = 0; i < sizeof(int); i++) {
        printf(" %02x", bytes[i]);
    }
    printf("\n");
    return 0;
}

Numa máquina little-endian isso imprime 01 00 00 00. Inspecionar a representação de um objeto através de um unsigned char * é um dos poucos casts de ponteiro que a norma abençoa explicitamente.

A maior parte dos outros casts de ponteiro não é abençoada. Ler um int através de um float * viola a regra de aliasing estrito e é comportamento indefinido mesmo compilando; use memcpy para reinterpretar bytes.

Duas convenções que vale conhecer. void * converte de e para qualquer tipo de ponteiro de objeto sem cast em C, e é por isso que você não deve converter o resultado do malloc:

int *arr = malloc(n * sizeof *arr);        /* C correto */
int *arr = (int *)malloc(n * sizeof *arr); /* desnecessario; esconde um cabecalho faltando */

O cast é obrigatório em C++, e é por isso que tanto código o tem. Em C ele pode esconder o erro de esquecer o <stdlib.h>.

E printf("%p", ...) espera um void *, então argumentos de ponteiro ali realmente precisam de um cast: printf("%p", (void *)p).

Quando um cast é a resposta errada

Um cast cala o compilador. Às vezes o compilador estava certo.

long big = 5000000000L;
int  small = (int)big;    /* o cast esconde perda real de dados */

Se o valor de fato cabe, o cast documenta que você conferiu. Se pode não caber, o cast converteu um aviso numa resposta errada silenciosa. Antes de escrever um, pergunte se a correção não é mudar o tipo de uma variável - double em vez de int, size_t em vez de int, long long em vez de long. Um cast é a ferramenta certa principalmente quando dois tipos corretos precisam se encontrar para uma operação, como em (double)sum / count.

Perguntas frequentes

Como se faz um cast em C?

Coloque o tipo de destino entre parênteses antes do valor: (double)x, (int)3.9, (char)65. O cast se aplica à expressão imediatamente seguinte, então (double)a / b converte a primeiro e depois divide, enquanto (double)(a / b) divide como inteiros e converte o resultado.

Como converter um int em float em C?

A atribuição faz isso implicitamente - double d = 5; guarda 5.0. Dentro de uma expressão você muitas vezes precisa de um cast explícito: (double)total / count força a divisão em ponto flutuante em vez da divisão inteira.

O que acontece quando você converte um float em int em C?

A parte fracionária é descartada - truncada em direção a zero, nunca arredondada. (int)3.9 é 3 e (int)-3.9 é -3. Para arredondar, some 0.5 antes do cast no caso de positivos, ou use round(), floor() ou ceil() de math.h.

Por que comparar um int com sinal e um sem sinal dá a resposta errada?

As conversões aritméticas usuais do C convertem o valor com sinal para sem sinal, então -1 < 1u é falso: -1 vira um número positivo enorme. Mantenha contagens e tamanhos com a mesma sinalização, ou converta explicitamente depois de checar que o valor não pode ser negativo.

Conceitos relacionados