Ámbito (Scope) y ciclo de vida en C++

En los programas de C++, cada variable tiene un alcance (scope) y un ciclo de vida (lifetime). El alcance determina en qué parte del programa se puede acceder a la variable, mientras que el ciclo de vida define cuánto tiempo permanece en la memoria. Estos conceptos son especialmente importantes en el uso de funciones, bucles y la gestión de memoria.

1. ¿Qué es el alcance (Scope)?

El alcance se refiere al área en la que una variable está definida. En C++, la accesibilidad de una variable está limitada por las llaves ({ }) donde se declara.

Alcance local

Las variables definidas dentro de una función o bloque solo son válidas dentro de ese bloque.

#include <iostream>
using namespace std;

int main() {
    int numero = 10; // variable local
    cout << numero << endl;
}
// 'numero' ya no es accesible aquí

En el ejemplo anterior, la variable numero solo se puede usar dentro de la función main().

2. Alcance a nivel de bloque

En C++, cada par de llaves ({ }) crea su propio ámbito. Esto es común en bucles e instrucciones condicionales.

int main() {
    int a = 5;

    if (a > 0) {
        int b = 10;  // solo es válida dentro de este bloque if
        cout << a + b << endl;
    }

    // cout << b; // Error! 'b' no es accesible aquí
    return 0;
}

Nota: Se pueden declarar variables con el mismo nombre en diferentes bloques. Sin embargo, una variable declarada en un bloque interno “oculta” la del bloque externo.

int x = 5;

int main() {
    int x = 10; // la variable externa 'x' queda oculta
    cout << x << endl; // 10
    return 0;
}

3. Alcance global

Las variables definidas fuera de todas las funciones se llaman variables globales. Se puede acceder a ellas desde cualquier parte del programa.

#include <iostream>
using namespace std;

int contador = 0; // variable global

void Incrementar() {
    contador++;
}

int main() {
    Incrementar();
    Incrementar();
    cout << "Contador: " << contador << endl; // 2
    return 0;
}

Las variables globales deben usarse con precaución, ya que pueden modificarse desde cualquier parte del programa.

4. La palabra clave static y el ciclo de vida

La palabra clave static se utiliza para modificar la duración de vida de una variable. Las variables static se crean solo una vez y permanecen en la memoria hasta que finaliza el programa.

#include <iostream>
using namespace std;

void Contar() {
    static int contador = 0; // se crea solo una vez
    contador++;
    cout << "La función fue llamada " << contador << " veces." << endl;
}

int main() {
    Contar();
    Contar();
    Contar();
    return 0;
}

Salida:

La función fue llamada 1 veces.
La función fue llamada 2 veces.
La función fue llamada 3 veces.

La variable static conserva su valor entre las llamadas a la función. Esto es útil para contadores o almacenamiento en caché.

5. El operador de resolución de ámbito (::)

Cuando existen variables locales y globales con el mismo nombre, se puede acceder a la variable global usando el operador de resolución de ámbito (::).

#include <iostream>
using namespace std;

int x = 100; // variable global

int main() {
    int x = 10; // variable local
    cout << "x local: " << x << endl;
    cout << "x global: " << ::x << endl; // acceso a la variable global
    return 0;
}

Salida:

x local: 10
x global: 100

6. Vida automática y estática

7. Ejemplo: Comparación de contadores

El siguiente ejemplo muestra la diferencia entre las variables automáticas y estáticas.

#include <iostream>
using namespace std;

void Contador() {
    int automatico = 0;
    static int persistente = 0;

    automatico++;
    persistente++;

    cout << "Automático: " << automatico 
         << " | Estático: " << persistente << endl;
}

int main() {
    Contador();
    Contador();
    Contador();
    return 0;
}

Salida:

Automático: 1 | Estático: 1
Automático: 1 | Estático: 2
Automático: 1 | Estático: 3

Como se puede ver, la variable automática se reinicia en cada llamada, mientras que la variable estática conserva su valor.

8. TL;DR

Artículos relacionados