En C++, el ámbito de una variable determina la parte del programa donde puede ser accedida y utilizada. Existen fundamentalmente tres tipos de variables según su declaración:

• Variables Locales: Declaradas dentro de una función o un bloque de código específico.
• Parámetros Formales: Declarados en la lista de parámetros de una función.
• Variables Globales: Declaradas fuera de cualquier función.

El ámbito se clasifica de la siguiente manera:

• Ámbito Local: Las variables declaradas dentro de una función solo son accesibles desde esa función. Se crean cada vez que la función es llamada y se destruyen al finalizar su ejecución.
• Ámbito Global: Las variables declaradas fuera de todas las funciones son accesibles desde cualquier parte del programa. Se crean al inicio de la ejecución del programa y se destruyen al finalizar.
• Ámbito de Bloque: Las varialbes declaradas dentro de un bloque de código (delimitado por llaves {}) solo son accesibles dentro de ese bloque. Se crean al entrar al bloque y se destruyen al salir.
• Ámbito de Clase: Las variables declaradas dentro de una clase son accesibles por los miembros de esa clase. Su ciclo de vida está ligado al de la clase.

Nota: Si una variable declarada en un ámbito interno tiene el mismo nombre que una variable en un ámbito externo, la variable interna "oculta" o "sobrescribe" a la externa dentro de su propio ámbito.

Variables Locales

Las variables locales se definen dentro de funciones o bloques y solo pueden ser utilizadas en ese contexto. A continuación, un ejemplo:

#include <iostream>

int main() {
    int num1, num2; // Variables locales
    int suma;

    num1 = 5;
    num2 = 15;
    suma = num1 + num2;

    std::cout << "La suma es: " << suma << std::endl;

    return 0;
}

Variables Globales

Las variables globales se declaran fuera de cualquier función, típicamente al inicio del archivo. Su valor es persistente durante toda la ejecución del programa y pueden ser accedidas desde cualquier función.

El siguiente ejemplo demuestra el uso de variables globales y locales:

#include <iostream>

// Variable global
int contadorGlobal;

int main() {
    // Variables locales
    int valorA, valorB;

    valorA = 10;
    valorB = 30;
    contadorGlobal = valorA + valorB; // Accediendo y modificando la variable global

    std::cout << "Valor global: " << contadorGlobal << std::endl;

    return 0;
}

Es posible que una variable local y una global compartan el mismo nombre. En este caso, dentro de la función donde se declara la variable local, esta última tendrá precedencia y ocultará a la global. Observe el siguiente ejemplo:

#include <iostream>

// Variable global
int datoCompartido = 50;

int main() {
    // Variable local con el mismo nombre
    int datoCompartido = 25;

    std::cout << "Dato local: " << datoCompartido << std::endl;

    return 0;
}

La ejecución de este código producirá:

25

Inicialización de Variables

Las variables locales no son inicializadas automáticamente por el sistema y deben ser inicializadas explícitamente por el programador. Las variables globales, en cambio, reciben un valor predeterminado:

Inicializar variables es una práctica de buena programación para evitar comportamientos inesperados.

Ámbito de Bloque

El ámbito de bloque se refiere a las variables declaradas dentro de un conjunto de llaves {}. Estas variables solo son accesibles dentro de dicho bloque.

#include <iostream>

int main() {
    int variableExterna = 10;

    { // Inicio de un bloque interno
        int variableInterna = 20; // Variable con ámbito de bloque
        std::cout << "Dentro del bloque: " << variableInterna << std::endl;
        // variableExterna también es accesible aquí
        std::cout << "Accediendo a variable externa desde el bloque: " << variableExterna << std::endl;
    } // Fin del bloque interno

    // variableInterna ya no es accesible aquí
    // std::cout << "Fuera del bloque: " << variableInterna << std::endl; // Esto generaría un error de compilación

    std::cout << "Fuera del bloque: " << variableExterna << std::endl;

    return 0;
}

Si se utiliza el mismo nombre para una variable en un ámbito externo y uno interno, la interna prevaleec dentro de su bloque:

#include <iostream>

int main() {
    int contador = 10; // Variable externa

    { // Bloque interno
        int contador = 20; // Variable local al bloque, oculta la externa
        std::cout << "Valor en el bloque: " << contador << std::endl;
    }

    std::cout << "Valor fuera del bloque: " << contador << std::endl;

    return 0;
}

La salida de este código será:

Valor en el bloque: 20
Valor fuera del bloque: 10

Ámbito de Clase

Las variables declaradas dentro de una clase tienen un ámbito de clase. Para acceder a ellas desde fuera de la clase, se utiliza el nombre de la clase seguido del operador de resolución de ámbito ::, especialmente si son miembros estáticos.

#include <iostream>

class MiClase {
public:
    // Variable de ámbito de clase (miembro estático)
    static int variableClase;
};

// Inicialización del miembro estático fuera de la declaración de la clase
int MiClase::variableClase = 30;

int main() {
    std::cout << "Variable de clase: " << MiClase::variableClase << std::endl;
    return 0;
}

La ejecución de este programa mostrará:

Variable de clase: 30