Variables, tipos de datos y operadores

De dónde venimos

En ¿Qué es C++? escribiste un programa que solo imprimía texto fijo, y en La Standard Library y tu primer main() apareció la primera variable de verdad:

std::string nombre;
std::cin >> nombre;

Ahí se coló mucha información sin explicar: por qué hay que escribir std::string antes del nombre, qué significa esa línea a nivel de memoria, y qué otros tipos existen además de std::string. Esta página cierra ese hueco. Todo lo que viene después en esta sección (control de flujo, funciones, punteros) se apoya en entender bien qué es una variable en C++.

Qué es una variable

Una variable es un espacio con nombre dentro de la memoria del programa, que guarda un valor de un tipo concreto. En C++ una variable tiene siempre tres cosas:

1. Un tipo (int, double, std::string…), decidido al escribirla y que ya no cambia.
2. Un nombre para referirte a ella.
3. Una dirección de memoria donde vive físicamente el valor.

Ese tercer punto parece un detalle irrelevante ahora, pero es exactamente lo que vas a necesitar cuando lleguemos a punteros: un puntero no es más que una variable que guarda la dirección de otra.

C++ es de tipado estático: el tipo se fija cuando compilas, no cuando ejecutas. Si declaras int edad;, esa variable jamás podrá contener texto. El compilador lo verifica y falla antes de generar el programa, que es justamente lo que lo hace rápido en tiempo de ejecución.

#include <iostream>
#include <string>

int main() {
    int edad = 30;                  // inicialización con =
    double altura{1.75};            // inicialización con llaves (C++11 en adelante)
    char inicial = 'C';             // comillas SIMPLES: un solo carácter
    bool activo = true;
    std::string nombre = "Camilo";  // comillas DOBLES: cadena de texto

    std::cout << nombre << " (" << inicial << "), " << edad
              << " años, " << altura << " m, activo: " << activo << "\n";
    return 0;
}

Compílalo y ejecútalo (si no tienes claro qué hace cada parte de este comando, la página del compilador lo explica en detalle):

g++ -std=c++17 -Wall -o variables variables.cpp
./variables

Camilo (C), 30 años, 1.75 m, activo: 1

Fíjate en el último dato: bool se imprime como 1 (verdadero) o 0 (falso), no como “true”/“false”. Es la primera de varias sorpresas pequeñas del lenguaje.

Los tipos fundamentales

Estos son los tipos que trae el lenguaje de fábrica, sin necesidad de ningún #include:

std::string no está en esta tabla a propósito: no es un tipo fundamental del lenguaje, sino una clase de la Standard Library. Por eso necesita #include <string> y lleva el prefijo std::, tal como se explicó en Namespaces y el prefijo std::.

auto: que el compilador deduzca el tipo

Desde C++11 puedes escribir auto y dejar que el compilador infiera el tipo a partir del valor inicial:

auto contador = 0;        // int
auto precio = 19.99;      // double
auto letra = 'x';         // char

Esto no convierte a C++ en un lenguaje de tipado dinámico: el tipo sigue siendo fijo y decidido en compilación, solo que no lo escribes tú. auto brilla sobre todo con tipos largos de la Standard Library (iteradores, plantillas), donde escribir el tipo completo sería ruido puro.

const: valores que no cambian

Anteponer const marca una variable como de solo lectura: el compilador rechaza cualquier intento de modificarla.

const double PI = 3.14159;
// PI = 3.0;  // ERROR de compilación: assignment of read-only variable 'PI'

Usar const no es una formalidad: le comunica tu intención al compilador y a quien lea el código, y evita modificaciones accidentales. Cobrará mucha más importancia cuando pases datos a funciones por referencia.

Operadores básicos

Aritméticos

El operador % solo funciona con enteros, y es más útil de lo que parece: n % 2 == 0 comprueba si un número es par, y aparecerá otra vez en la página de control de flujo.

Comparación y lógicos

Los de comparación devuelven un bool: == (igual), != (distinto), <, >, <=, >=.

Los lógicos combinan condiciones: && (y), || (o), ! (no).

Incremento, decremento y asignación compuesta

• ++i / i++ suman 1; --i / i-- restan 1.
• +=, -=, *=, /= combinan operación y asignación: total += 5 es total = total + 5.

La diferencia entre ++i (pre-incremento: incrementa y luego devuelve el valor nuevo) e i++ (post-incremento: devuelve el valor viejo y luego incrementa) solo importa cuando usas el resultado dentro de una expresión más grande. En un bucle suelto, ambos hacen lo mismo. Por cierto, el nombre del lenguaje viene precisamente de este operador: C++ es “C incrementado en uno”.

Ejemplo completo: promedio de dos notas

Este programa junta todo lo anterior con la entrada por consola que ya viste con std::cin:

#include <iostream>

int main() {
    double nota1 = 0.0;
    double nota2 = 0.0;

    std::cout << "Ingresa la primera nota: ";
    std::cin >> nota1;
    std::cout << "Ingresa la segunda nota: ";
    std::cin >> nota2;

    const double promedio = (nota1 + nota2) / 2.0;   // 2.0, no 2, para evitar división entera

    std::cout << "Promedio: " << promedio << "\n";
    std::cout << "¿Aprobado? " << (promedio >= 4.0) << "\n";
    return 0;
}

g++ -std=c++17 -Wall -o promedio promedio.cpp
./promedio

Ingresa la primera nota: 5.5
Ingresa la segunda nota: 3.5
Promedio: 4.5
¿Aprobado? 1

Fíjate que aquí las variables son double, así que (nota1 + nota2) / 2.0 sí produce decimales. El 2.0 está escrito así deliberadamente: aunque en este caso 2 también funcionaría (porque los operandos ya son double), acostumbrarte a escribir el punto decimal te ahorra la trampa cuando trabajes con enteros.

Siguiente paso

Ya sabes guardar y operar valores, pero el programa sigue ejecutándose siempre de arriba a abajo, línea por línea. Para que tome decisiones y repita trabajo, sigue con Control de flujo: if, for, while y switch.