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.

Tabla de Contenidos

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;
}

programa completo compilado y ejecutado en Fedora

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.

Types and variables in C — what changes from Python and what doesn’t

Types and variables in C are the first thing you need to master. If you come from Python some things will look familiar, operators are almost the same, but there are key differences that will cause errors for weeks if you don’t understand them. Real gedit screenshots on Fedora throughout.

If you don’t have the environment set up yet, follow the gedit and gcc guide first.

First — C is not Python

Three fundamental differences:

1. You must declare the type of every variable before using it. Python: x = 5. C: int x = 5;

2. Every instruction ends with ;. Forgetting it is the most common syntax error.

3. There is no boolean type in C. No True or False. Use int where 0 is false and anything else is true.

Basic types in C

int     // integer
char    // character (1 byte)
float   // single precision decimal
double  // double precision decimal

Type modifiers

unsigned int x;    // positive only: 0 to 4,294,967,295
short int x;       // smaller range, less memory
long int x;        // larger range
long long int x;   // very large range

Variable declarations

int age = 20;
float grade = 7.5;
char letter = 'A';
int a, b, c;
unsigned int counter = 0;

Literals

int decimal     = 1234;
int hexadecimal = 0x1234;    // starts with 0x
int octal       = 01234;     // starts with 0 ← careful!
char character  = 'A';
float real      = 3.456e6;

⚠️ int x = 010; is NOT 10 — it’s 8 (octal). Silent mistake.

Operators

+  -  *  /  %    // arithmetic
== != > < >= <=  // comparison
&& || !          // logical (like and, or, not in Python)

Integer division in C

int result = 7 / 3;         // → 2 (truncated, not 2.33)
float result = 7.0 / 3;     // → 2.333...
float result = (float)7 / 3; // → 2.333... (explicit cast)

In Python 7/3 always gives 2.333.... In C dividing two integers always gives an integer.

No boolean in C

(3 > 2)     // returns 1 (true)
(3 == 2)    // returns 0 (false)
if (1)      // always executes
if (0)      // never executes
if (-5)     // executes (non-zero = true)

Pre/post increment

int x = 1;
int a = x++;    // a = 1, x = 2 (use then increment)
int b = ++x;    // b = 3, x = 3 (increment then use)

printf and scanf

#include <stdio.h>

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

printf("Integer: %d\n", x);
printf("Float: %f\n", f);
printf("Char: %c\n", c);

scanf("%d", &x);     // & is MANDATORY
scanf("%f", &f);     // & is MANDATORY

Format specifiers:

%d    // int
%ld   // long
%f    // float
%lf   // double
%c    // char
%s    // string

The mandatory `&` in scanf

scanf("%d", x);     // WRONG — compiles but undefined behaviour
scanf("%d", &x);    // RIGHT — & means "address of"

scanf needs the memory address of the variable to store the value. & gives the address. This is related to pointers — for now just remember: scanf always needs &.

Understanding printf/scanf format strings

printf("Result: %d\n", variable);
//      ├──────┤ ├┤    ├───────┘
//      text   %d    variable

Each %d, %f, %c is a slot for the corresponding variable. Order matters:

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

Complete program

#include <stdio.h>

int main() {
    int age;
    float grade;
    char initial;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Enter your grade (0-10): ");
    scanf("%f", &grade);

    printf("Enter your initial: ");
    scanf(" %c", &initial);

    int adult = (age >= 18);
    float grade_100 = grade * 10;

    printf("\n--- Results ---\n");
    printf("Age: %d years\n", age);
    printf("Grade: %.2f (out of 100: %.1f)\n", grade, grade_100);
    printf("Initial: %c\n", initial);
    printf("Adult: %d\n", adult);

    return 0;
}

Quick summary

// BASIC TYPES
int x = 5;
float f = 3.14;
double d = 3.14;
char c = 'A';

// KEY RULES
// 1. Always declare type before using variable
// 2. Every instruction ends with ;
// 3. No boolean — 0 is false, anything else is true
// 4. Integer division truncates (7/3 = 2)
// 5. scanf always needs & before variable

// PRINTF AND SCANF
printf("%d %f %c\n", integer, float_var, char_var);
scanf("%d", &integer);    // & MANDATORY