Tipos y variables en C — lo que cambia respecto a Python y lo que no

Los tipos y variables en C son lo primero que necesitas dominar para programar en IC2. Si vienes de Python, algunas cosas te sonarán, los operadores son casi iguales, pero hay diferencias importantes que si no entiendes bien te van a dar errores durante semanas.

En este artículo vemos los tipos básicos, cómo declarar variables, los operadores y cómo usar printf y scanf correctamente. Con capturas reales de gedit en Fedora.

Si todavía no tienes el entorno configurado, primero sigue la guía de instalar gedit y compilar con gcc.

Lo primero — C no es Python

Antes de empezar, tres diferencias fundamentales que tienes que tener claras:

1. En C tienes que declarar el tipo de cada variable antes de usarla. En Python escribías x = 5 y listo. En C tienes que decir explícitamente que x es un entero: int x = 5;. Si no declaras el tipo, error de compilación.

2. Cada instrucción termina en ;. En Python los saltos de línea son suficientes. En C el ; es obligatorio, olvidarlo es el error de sintaxis más común al empezar.

3. No hay tipo booleano en C. En Python tienes True y False. En C no existe ese tipo, se usa int donde 0 es falso y cualquier otro número es verdadero. Esto confunde mucho al principio.

Tipos y variables en C

C tiene solo cuatro tipos básicos, todos numéricos:

int     // número entero
char    // carácter (1 byte — también se usa como entero pequeño)
float   // número decimal de precisión simple
double  // número decimal de doble precisión

A diferencia de Python donde x = 7.5 simplemente funciona, en C tienes que elegir el tipo correcto desde el principio. La tabla de tamaños que vimos en el PDF de IC2:

char      → 1 byte  → -128 a 127
short     → 2 bytes → -32.768 a 32.767
int       → 4 bytes → -2.147.483.648 a 2.147.483.647
long      → 4-8 bytes
float     → 4 bytes → ±3.4e38
double    → 8 bytes → ±1.7e308

Modificadores — afinar el tipo

A los tipos básicos puedes añadirles modificadores que cambian su rango:

unsigned int x;     // solo positivos: 0 a 4.294.967.295
signed int x;       // positivos y negativos (por defecto)
short int x;        // entero corto — menos memoria
long int x;         // entero largo — más rango
long long int x;    // entero muy largo

El más usado en IC2 es unsigned cuando sabes que el valor nunca será negativo, por ejemplo un contador o un tamaño de array.

Declarar variables

La sintaxis de declaración en C es:

tipo nombre;              // declaración sin valor inicial
tipo nombre = valor;      // declaración con valor inicial
tipo nombre1, nombre2;    // varias variables del mismo tipo

Ejemplos reales:

int edad = 20;
float nota = 7.5;
char letra = 'A';
int a, b, c;
unsigned int contador = 0;

Importante: C distingue mayúsculas: edad, Edad y EDAD son tres variables distintas. Igual que en Python.

Literales — los valores que escribes directamente

En C puedes escribir números en diferentes bases:

int decimal     = 1234;      // base 10 — lo normal
int hexadecimal = 0x1234;    // base 16 — empieza por 0x
int octal       = 01234;     // base 8  — empieza por 0
char caracter   = 'A';       // carácter entre comillas simples
float real      = 3.456e6;   // notación científica

⚠️ Ojo con el octal: si escribes int x = 010; no estás poniendo el número 10 sino el 8 (010 en octal = 8 en decimal). Es un error silencioso muy típico.

Operadores en C

Los operadores aritméticos son casi iguales a Python:

+    // suma
-    // resta
*    // multiplicación
/    // división
%    // módulo (resto)

Pero hay una trampa importante con la división

La división entera en C

Si divides dos enteros en C el resultado es siempre entero, se trunca sin redondear:

int resultado = 7 / 3;      // → 2  (no 2.33)
float resultado = 7.0 / 3;  // → 2.333... (uno debe ser float)
float resultado = (float)7 / 3;  // → 2.333... (cast explícito)

En Python 7 / 3 siempre da 2.333... y 7 // 3 da 2. En C la división entre enteros siempre da entero — no hay // para esto.

Operadores de comparación y lógicos

==    // igual (doble = para comparar)
!=    // distinto
>     // mayor que
<     // menor que
>=    // mayor o igual
<=    // menor o igual
&&    // AND lógico (equivale a and en Python)
||    // OR lógico (equivale a or en Python)
!     // NOT lógico (equivale a not en Python)

No hay booleano en C — cómo funciona la lógica

Este es uno de los conceptos que más confunden viniendo de Python. En C no existe True ni False. Las condiciones devuelven un entero:

(3 > 2)    // devuelve 1 (verdadero)
(3 == 2)   // devuelve 0 (falso)
(3 > 2) && (5 > 1)    // devuelve 1

Y cualquier entero distinto de 0 se considera verdadero:

if (1)     // siempre se ejecuta
if (0)     // nunca se ejecuta
if (-5)    // se ejecuta (distinto de 0 = verdadero)

Esto tiene consecuencias prácticas, en C puedes escribir if (x) en vez de if (x != 0) y funcionan igual.

Pre/post incremento y decremento

C tiene una sintaxis que Python no tiene, el operador ++ y --:

x++    // post-incremento: usa x y luego suma 1
++x    // pre-incremento: suma 1 y luego usa x
x--    // post-decremento
--x    // pre-decremento

La diferencia importa cuando lo usas dentro de una expresión:

int x = 1;
int a = x++;    // a vale 1, x vale 2 (usa primero, incrementa después)
int b = ++x;    // b vale 3, x vale 3 (incrementa primero, usa después)

Asignación compuesta

a += 3;     // equivale a a = a + 3
a -= 2;     // equivale a a = a - 2
a *= x+1;   // equivale a a = a * (x+1)
a /= 4;     // equivale a a = a / 4
a %= 3;     // equivale a a = a % 3

Igual que en Python, += es el más usado en bucles e IC2.

printf y scanf — leer y escribir datos

Estas dos funciones son las más importantes del lenguaje para entrada y salida de datos. Requieren #include <stdio.h> al principio del fichero.

printf — escribir en pantalla:

int x = 5;
float f = 3.14;
char c = 'A';

printf("El entero es: %d\n", x);
printf("El flotante es: %f\n", f);
printf("El carácter es: %c\n", c);
printf("Dos valores: %d y %f\n", x, f);

Las cadenas de formato más usadas:

%d    // entero decimal (int)
%ld   // entero largo (long)
%f    // flotante (float)
%lf   // doble precisión (double)
%c    // carácter (char)
%s    // cadena de texto
%x    // entero en hexadecimal
%o    // entero en octal

scanf — leer desde teclado:

int x;
float f;
char c;

scanf("%d", &x);    // lee un entero
scanf("%f", &f);    // lee un flotante
scanf("%c", &c);    // lee un carácter
scanf("%d %f", &x, &f);    // lee dos valores

El & obligatorio en scanf — el error más común

Este es el punto que más confunde y más errores genera en IC2. El & delante de la variable en scanf es obligatorio y no es opcional.

// MAL — sin & (compila pero da comportamiento indefinido)
scanf("%d", x);

// BIEN — con &
scanf("%d", &x);

¿Por qué? Porque scanf necesita saber dónde guardar el valor que lee, necesita la dirección de memoria de la variable, no su valor. El & significa «dirección de». Esto está relacionado con los punteros que veremos más adelante, por ahora simplemente recuerda: scanf siempre lleva &.

Entender el formato de printf y scanf

Este fue el concepto que más me costó entender al principio. La cadena de formato es el texto entre comillas que le dices cómo interpretar los datos:

printf("El resultado es: %d\n", variable);
//      ├─────────────┤  ├┤     ├──────┘
//      texto literal    %d     variable
//                       ↑
//                       especificador de formato

Cada %d, %f, %c es un hueco donde va a insertar el valor de la variable correspondiente. El orden importa, el primer % corresponde a la primera variable, el segundo al segundo, etc.:

printf("%d mas %d es %d\n", 3, 4, 3+4);
// → 3 mas 4 es 7

Programa completo — juntando todo

Aquí tienes un programa que usa todo lo que hemos visto:

#include <stdio.h>

int main() {
    /* declaración de variables */
    int edad;
    float nota;
    char inicial;

    /* lectura de datos */
    printf("Introduce tu edad: ");
    scanf("%d", &edad);

    printf("Introduce tu nota (0-10): ");
    scanf("%f", &nota);

    printf("Introduce tu inicial: ");
    scanf(" %c", &inicial);    // el espacio antes de %c es importante

    /* cálculos */
    int mayor_edad = (edad >= 18);    // 1 si es mayor, 0 si no
    float nota_sobre_100 = nota * 10;

    /* salida de resultados */
    printf("\n--- Resultados ---\n");
    printf("Edad: %d años\n", edad);
    printf("Nota: %.2f (sobre 100: %.1f)\n", nota, nota_sobre_100);
    printf("Inicial: %c\n", inicial);
    printf("Mayor de edad: %d\n", mayor_edad);

    return 0;
}

Fíjate en %.2f — el .2 indica cuántos decimales mostrar. %.2f muestra 2 decimales, %.0f no muestra decimales.

Resumen rápido

// TIPOS BÁSICOS
int x = 5;          // entero
float f = 3.14;     // decimal simple
double d = 3.14;    // decimal doble precisión
char c = 'A';       // carácter

// REGLAS IMPORTANTES
// 1. Declarar tipo siempre antes de usar la variable
// 2. Cada instrucción termina en ;
// 3. No hay booleano — 0 es falso, cualquier otro es verdadero
// 4. División entre enteros = resultado entero (7/3 = 2)
// 5. scanf siempre lleva & delante de la variable

// PRINTF Y SCANF
printf("%d %f %c\n", entero, flotante, caracter);
scanf("%d", &entero);    // & OBLIGATORIO

En el próximo artículo practicamos todo esto con programas reales en gedit, calculadoras, conversores y validadores de datos usando C.