1. Variables int: por qué sirven y cómo trabajar con ellas
Al principio parece que los números en un programa se pueden usar «como en la libreta»: escribes 2 + 2 — y listo. Pero un programa real normalmente no vive en una sola línea: guarda datos, los modifica, usa el resultado varias veces e imprime partes diferentes en distintos lugares. Por eso necesitamos una forma de decir: «Este número es importante, vamos a darle un nombre y referirnos a él».
El tipo int es la herramienta más básica para eso. Almacena números enteros: 0, 7, -12, 42. Sin parte fraccionaria. Puedes pensar en él como una «caja para un número entero» a la que ponemos una etiqueta (el nombre de la variable) para no confundirnos.
Declaración, valor inicial y asignación
Cuando creas una variable haces dos cosas: le das un nombre y eliges el tipo, es decir qué se va a almacenar. Y luego normalmente le das un valor inicial para que la variable no esté «vacía» (en C++ eso es especialmente importante).
Veamos el ejemplo mínimo. Aquí no hacemos nada sofisticado: solo guardamos la edad y la imprimimos. Pero casi todo programa empieza así: con datos.
#include <iostream>
int main() {
int age = 18;
std::cout << "Age = " << age << '\n'; // Age = 18
}
Fíjate en tres puntos. Primero, int age = 18; se lee como «crea la variable age de tipo int y ponle 18». Segundo, en std::cout se puede imprimir texto y números, simplemente «concatenándolos» con el operador <<. Tercero, el carácter de nueva línea '\n' ayuda a que la salida sea ordenada.
Ahora lo más importante: una variable no es una constante. Su valor se puede cambiar mediante la asignación.
#include <iostream>
int main() {
int score = 0;
std::cout << score << '\n'; // 0
score = 10;
std::cout << score << '\n'; // 10
}
La línea score = 10; significa «reemplaza el valor antiguo por uno nuevo». Y sí: el signo = en programación normalmente significa no «igual», sino «asigna/escribe».
2. Aritmética con int y paréntesis en expresiones
Operaciones +, -, * para enteros
Con la aritmética en int todo se ve muy familiar, y eso es bueno: suma, resta y multiplicación funcionan «como esperas». Sin embargo, hay un matiz importante: el resultado también será entero, porque trabajamos en el mundo de int. Esto suena obvio ahora, pero con la división se nota más — y llegaremos a eso.
Empecemos con lo básico: sumemos, restemos y multipliquemos.
#include <iostream>
int main() {
int a = 7;
int b = 2;
std::cout << (a + b) << '\n'; // 9
std::cout << (a - b) << '\n'; // 5
std::cout << (a * b) << '\n'; // 14
}
Los paréntesis no son obligatorios aquí, pero a los principiantes suelen salvarles la vida: muestran claramente qué quieres calcular y reducen las posibilidades de convertir la expresión en un rompecabezas.
Otro truco útil es guardar el resultado de un cálculo en una variable. Eso hace el código más legible: primero calculas, después usas.
#include <iostream>
int main() {
int apples = 3;
int pears = 4;
int total = apples + pears;
std::cout << total << '\n'; // 7
}
Paréntesis: por sentido y legibilidad
Cuando las expresiones se alargan, la cabeza hace lo mismo que el compilador: intenta entender el orden de evaluación. El problema es que la persona se cansa y el compilador no. Por eso un buen estilo en programación suele ser «pon paréntesis donde a una persona le pueda no quedarle claro». No es debilidad, es cuidado con tu yo del futuro (y con la persona que revisará tu código).
Compara dos variantes: formalmente pueden ser equivalentes, pero se leen de forma distinta.
#include <iostream>
int main() {
int x = 10;
int y = 3;
int r1 = x + y * 2;
int r2 = (x + y) * 2;
std::cout << r1 << '\n'; // 16
std::cout << r2 << '\n'; // 26
}
Los paréntesis cambian el significado. Y esa es una buena regla para recordar: si la fórmula es importante, mejor hacerla evidente a la vista en vez de confiar en la memoria sobre la prioridad de operadores.
3. División / y resto % para int
División /: el resultado siempre es entero
El operador / para int realiza una división entera. Esto significa: el resultado también es int, y la parte fraccionaria no se redondea «según las reglas matemáticas», sino que simplemente se descarta.
Comprobémoslo con el ejemplo clásico:
#include <iostream>
int main() {
int a = 7;
int b = 2;
std::cout << (a / b) << '\n'; // 3
}
¿Por qué 3 y no 3.5? Porque int no puede almacenar .5. Solo guarda valores enteros. Por eso el programa toma la parte entera y descarta lo demás.
Este comportamiento es útil cuando calculas «cuántos objetos enteros caben». Por ejemplo, cuántos paquetes de galletas de 6 unidades puedes formar con 25 galletas. Pero el mismo comportamiento es peligroso si esperabas una división «real». Mientras trabajemos solo con int, recuerda la regla: int / int da como resultado int.
Cabe añadir que con números negativos el resultado también es entero. En el C++ moderno la fracción se descarta hacia cero, es decir -7 / 2 será -3.
#include <iostream>
int main() {
int a = -7;
int b = 2;
std::cout << (a / b) << '\n'; // -3
}
Si estás pensando «mmm, ¿y cuál sería el resto?» — estás pensando como un programador. Pasamos al %.
Resto %: lo que queda después de dividir
El operador % se lee como «resto de la división». Funciona solo con enteros (en nuestro caso — con int). Suele usarse en problemas tipo «repartir en cajas» o «hacer el cambio» o «saber si un número es divisible».
El ejemplo más básico:
#include <iostream>
int main() {
int a = 7;
int b = 2;
std::cout << (a % b) << '\n'; // 1
}
Es decir, repartir 7 naranjas entre 2 personas da 3 naranjas para cada una y 1 de resto.
Es útil recordar la relación entre división y resto con la fórmula: a = (a / b) * b + (a % b)
No es magia ni un conjuro, sino una forma precisa de decir: «el número a consiste en un número entero de grupos de b más un resto».
Comprobémoslo en código:
#include <iostream>
int main() {
int a = 25;
int b = 6;
int q = a / b; // cuántos grupos completos
int r = a % b; // cuánto queda
std::cout << q << '\n'; // 4
std::cout << r << '\n'; // 1
}
Por ahora puede parecer un «juguete», pero tras resolver unos cuantos ejercicios empezarás a ver el operador % por todas partes: hora en el reloj, paridad, paginación, conversión de segundos a minutos, etc.
4. Dividir por cero no está permitido
En matemáticas dividir por cero no está definido. En programación esto se convierte en un problema práctico: las expresiones a / 0 y a % 0 no están permitidas. El programa o bien fallará de forma abrupta, o bien tendrá un comportamiento totalmente impredecible (peor aún, los errores pueden manifestarse «más tarde»).
Aquí lo importante no es el miedo, sino la costumbre: si tienes un divisor que teóricamente puede ser cero, debes controlarlo. Todavía no hemos visto if, así que hoy la regla es simple: en ejemplos y ejercicios iniciales no dividas por cero y ten en mente que el divisor debe ser distinto de cero.
5. Mini‑aplicación: «Máquina expendedora con monedas»
Ahora escribiremos un pequeño programa con apariencia de «situación real»: tenemos una cantidad de dinero y el precio de un producto, y queremos saber dos cosas. Primero, cuántos productos se pueden comprar. Segundo, cuánto dinero queda. Es una tarea ideal para combinar / y %.
Importante: como todavía no sabemos leer entrada, los números estarán «hardcodeados» en el código. Está bien: hoy no buscamos entrada, sino aritmética.
Versión 1: calculamos cantidad y cambio
Imagina que tienes 275 céntimos (es decir $2.75), y la galleta cuesta 60 céntimos. Calculamos.
#include <iostream>
int main() {
int moneyCents = 275;
int cookiePrice = 60;
int cookies = moneyCents / cookiePrice;
int change = moneyCents % cookiePrice;
std::cout << cookies << '\n'; // 4
std::cout << change << '\n'; // 35
}
Aquí se ve claramente por qué usamos variables: definimos precio y cantidad una vez y luego los usamos en cálculos, pudiendo cambiar el escenario sin reescribir todo el programa.
Versión 2: hacemos la salida más entendible
Por ahora la salida es «ordenadorizada»: solo números en columna. Añadamos etiquetas para que parezca una consola normal. No usamos cadenas como tipo (eso será en la siguiente lección), pero ya sabemos imprimir texto entre comillas.
#include <iostream>
int main() {
int moneyCents = 275;
int cookiePrice = 60;
int cookies = moneyCents / cookiePrice;
int change = moneyCents % cookiePrice;
std::cout << "Cookies: " << cookies << '\n'; // Cookies: 4
std::cout << "Change: " << change << " cents\n"; // Change: 35 cents
}
Sí, esto ya parece una aplicación y no un control de ejercicios de aritmética.
Versión 3: otra compra más
Supongamos que después de comprar galletas quieres comprar un chicle por 35 céntimos. Justo tienes cambio. Calculemos cuántos chicles puedes comprar con el cambio (esto también usa / y %, solo con otros números).
#include <iostream>
int main() {
int moneyCents = 275;
int cookiePrice = 60;
int gumPrice = 35;
int cookies = moneyCents / cookiePrice;
int changeAfterCookies = moneyCents % cookiePrice;
int gums = changeAfterCookies / gumPrice;
std::cout << "Cookies: " << cookies << '\n'; // Cookies: 4
std::cout << "Gums: " << gums << '\n'; // Gums: 1
}
Aquí se aprecia especialmente que las variables ayudan a mantener el «argumento» del programa. No solo calculamos números, describimos un proceso.
6. Errores típicos al trabajar con int, / y %
Error nº1: esperar que 7 / 2 dé 3.5.
Es una de las trampas más comunes para los principiantes: la mente recuerda la matemática escolar, pero el programa trabaja en el mundo de int. En la división entera la parte fraccionaria se descarta porque int no puede guardar mitades. Si necesitas fracciones —eso es otro tema— hoy vivimos honestamente en el mundo de los enteros y aceptamos sus reglas.
Error nº2: usar % «para todo».
El resto no es un «botón mágico», sino una operación concreta que significa «lo que queda tras repartir en grupos iguales». Si no puedes explicar con palabras qué queda exactamente, probablemente estás usando % al azar. Adivinar en programación funciona parecido a adivinar una contraseña: a veces cuela, pero mejor no.
Error nº3: olvidar que a % 0 y a / 0 no son válidos.
Dividir por cero no solo «da un error». Rompe la lógica del cálculo. Por eso la regla es sencilla: el divisor debe ser distinto de cero. Más adelante, cuando aparezcan las condiciones (if), aprenderás a proteger el programa de ese caso. De momento — simplemente no escribas ese código ni pongas 0 como divisor.
Error nº4: escribir expresiones largas sin paréntesis y luego no entender el resultado.
Formalmente el compilador lo interpreta, pero una persona no siempre. Al final tienes «todo parece correcto, ¿por qué la respuesta no es la esperada?» . Los paréntesis son una forma barata de hacer el significado evidente para ti y para quien lea el código. En programación eso no es pedantería, es prevención de bugs.
Error nº5: confundir “crear una variable” y “modificar una variable”.
int x = 10; — eso crea la variable con un valor inicial. x = 10; — eso asigna a una variable ya existente. Si intentas «crear» una variable de nuevo con el mismo nombre en el mismo ámbito, el compilador te lo recriminará: «espera, ya existe x».
GO TO FULL VERSION