Variables en C++: declaración, inicialización y ámbito explicados

Qué es una variable

Una variable es una porción de memoria con nombre que contiene un valor. En C++ toda variable tiene un tipo fijo - elegido cuando la declaras - y ese tipo nunca cambia. Esto es lo que hace que C++ sea de tipado estático: el compilador conoce el tipo de cada variable antes de que el programa se ejecute y se niega a compilar código que guarde un valor del tipo equivocado.

Una declaración tiene tres partes: el tipo, el nombre y (casi siempre) un valor inicial.

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 30;
    string name = "Ada";
    bool isActive = true;

    cout << name << " is " << age << ", active: " << isActive << "\n";
    return 0;
}

Lee int age = 30; como "crea un int llamado age y mete 30 en él". El punto y coma termina la sentencia, igual que la página de comentarios mostró que hace toda sentencia. Fíjate en que isActive se imprimió como 1: un bool se muestra como 1/0 por defecto, algo sobre lo que se apoya la página de tipos de datos.

Inicialización vs. asignación

Estas dos cosas se parecen pero son operaciones distintas, y la diferencia es una de las ideas más importantes de esta página.

La inicialización le da a una variable su primer valor como parte de la declaración. La asignación cambia el valor de una variable que ya existe.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // inicialización - primer valor, dado en la declaración
    score = 100;      // asignación - cambiar una variable existente
    score = score + 5;

    cout << score << "\n";
    return 0;
}

Puedes declarar sin inicializar y asignar después, pero ten cuidado:

#include <iostream>
using namespace std;

int main() {
    int score;     // declarada, pero ahora mismo contiene basura
    score = 95;    // ahora tiene un valor real
    cout << score << "\n";
    return 0;
}

Eso funciona porque asignamos score antes de leerlo. La versión peligrosa es leerlo primero, lo que veremos a continuación.

El peligro de la variable sin inicializar

Esta es la trampa clásica de C++ que no existe en muchos otros lenguajes. Leer una variable local que se declaró pero a la que nunca se le dio un valor es comportamiento indefinido: la variable contiene los bytes que casualmente estuvieran en esa memoria.

int score;             // no inicializada
std::cout << score;    // comportamiento indefinido - imprime basura, o "funciona", o falla

El compilador construirá esto sin protestar. Puede imprimir 0, puede imprimir 32766, y puede comportarse de forma diferente en cada ejecución o en cada máquina, lo que hace que estos errores sean horribles de rastrear. Dos defensas:

• Inicializa siempre en la declaración. int score = 0; no cuesta nada y elimina el problema por completo.
• Activa las advertencias. Compilar con -Wall -Wextra hace que el compilador señale muchas lecturas sin inicializar antes de que te muerdan.

Prefiere la primera opción para cada variable local: dale un valor inicial sensato en el momento mismo en que la creas.

Estilos de inicialización: =, () y {}

C++ te da varias maneras de escribir un valor inicial. En su mayoría hacen lo mismo, pero la inicialización con llaves tiene una característica de seguridad extra que vale la pena conocer.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // inicialización por copia
    int b(5);      // inicialización directa
    int c{5};      // inicialización con llaves (uniforme) - C++11 y posteriores

    cout << a << " " << b << " " << c << "\n";
    return 0;
}

La razón para recurrir a {} es que rechaza las conversiones con estrechamiento (narrowing): asignaciones que perderían datos de forma silenciosa. Con =, un valor fraccionario se trunca sin avisar; con {}, el compilador te detiene:

int x = 3.9;    // compila - x se convierte silenciosamente en 3 (el .9 se descarta)
int y{3.9};     // error de compilación - el estrechamiento de double a int no está permitido

Detectar eso en tiempo de compilación es justo lo que quieres. Una costumbre moderna habitual es usar {} por defecto para esa comprobación extra, recurriendo a = solo cuando la inicialización por copia se lee de forma más natural.

Reglas y convenciones de nombres

C++ impone unas pocas reglas estrictas, y luego todo el mundo le añade convenciones encima. Las reglas: un nombre puede contener letras, dígitos y _; no puede empezar por un dígito; no puede ser una palabra reservada (como int o return); y distingue mayúsculas de minúsculas (age y Age son dos variables distintas). Evita nombres que empiecen por un guion bajo seguido de una mayúscula, o que contengan dos guiones bajos seguidos: están reservados para la implementación.

Las convenciones que sigue la mayoría del código C++:

• Las variables usan snake_case o camelCase: elige una y mantén la coherencia: item_count o itemCount.
• Los nombres deben describir el valor: count, no c; user_email, no x.

#include <iostream>
using namespace std;

int main() {
    int item_count = 3;
    double price_per_item = 4.50;
    double total_price = item_count * price_per_item;

    cout << "Total: " << total_price << "\n";
    return 0;
}

Los nombres claros no son adorno: son la forma en que tu yo futuro lee el código. total_price = item_count * price_per_item se explica solo de una manera que t = c * p nunca logrará.

Ámbito de las variables

Una variable existe solo dentro del bloque - las { ... } - donde se declara, y se destruye en la llave de cierre. Esto es su ámbito (scope). Una variable declarada dentro de un bucle o de un bloque if es invisible fuera de él:

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' vive solo dentro del cuerpo de este bucle
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // error - 'square' está fuera de ámbito aquí
    return 0;
}

Tanto i como square pertenecen al bucle y desaparecen cuando este termina; total se declara en el bloque exterior, así que sobrevive. Un bloque interno también puede eclipsar (shadow) un nombre de un bloque externo: una nueva variable con el mismo nombre oculta temporalmente a la externa hasta que el bloque interno se cierra, lo cual es una fuente frecuente de confusión, así que evita reutilizar nombres entre ámbitos anidados.

La conclusión práctica: declara cada variable en el bloque más pequeño que la necesite e inicialízala ahí. Un ámbito reducido significa menos nombres compitiendo por tu atención y menos posibilidades de leer un valor lejos de donde se estableció.

Siguiente: Tipos de datos

Cada variable de esta página empezó con un tipo - int, double, string, bool. La siguiente página desglosa en detalle los tipos de datos de C++: los tipos fundamentales y sus tamaños, enteros con y sin signo, float frente a double, char, y cómo elegir el tipo adecuado para cada tarea.