c++ - ¿Cómo acceder a una variable global dentro de un ámbito local?

global-variables

Question

Este es mi codigo

#include <iostream>
using namespace std;
int x = 5;
int main()
{
int x = 1;
cout << "The variable x: " << x << endl;
} 

Me sale como salida 1 , pero me gustaría tener 5 , como para acceder a la variable x global.

es posible?

Answer 1

Debe utilizar ::x para acceder a la variable global en el ámbito local. El operador :: es operador de resolución de alcance único. Entonces tu código debería ser:

 #include <iostream>
using namespace std;
int x = 5;
int main()
{
int x = 1;
cout << "The variable x: " << ::x << endl;
} 

Nota: :: operador tiene dos significados en C ++:

1. Operador de resolución de ámbito binario.
2. Operador de resolución de alcance unario.

Casi durante sus horas completas de codificación, estaría usando el operador de resolución de alcance binario. Entonces, aunque la respuesta a esta pregunta es un operador de resolución de alcance único; Sólo para futuras referencias, enlisto algunos casos de uso típicos del operador de resolución de alcance binario.

Casos de uso del operador de resolución de alcance binario:

1. Para definir tus funciones fuera de la clase.

Organizamos nuestro código en archivos de encabezado con extensión .h y archivos de código con extensión .cpp . Al definir nuestras funciones en los archivos de código, usamos el operador de resolución de ámbito binario.

Por ejemplo, un archivo Car.h se parece a:

class Car
{
private:
int model;
int price;
public:
void drive();
void accelerate();
};

Y Car.cpp se vería como:

void Car :: drive()
{
// Driving logic.
}
void Car :: accelerate()
{
// Logic for accelerating.
}

Aquí, como podemos notar fácilmente, :: actúa sobre dos operandos:

1. El nombre de la clase
2. El nombre de la función

Por lo tanto, esencialmente define el alcance de la función, es decir, informa al compilador que la función drive () pertenece a la clase Car.

2. Para resolver la ambigüedad entre dos funciones con la misma plantilla que se derivan de diferentes clases.

Considere el siguiente código:

#include <iostream>
using namespace std;
class Vehicle
{
public:
void drive()
{
cout << "I am driving a Vehicle./n";
}
};
class Car
{
public:
void drive()
{
cout << "I am driving a Car./n";
}
};
class BMW : public Car, public Vehicle
{
// BMW specific functions.
};
int main(int arc, char **argv)
{
BMW b;
b.drive(); // This will give compile error as the call is ambiguous.
b.Car::drive(); // Will call Car''s drive method.
b.Vehicle::drive(); // Will call Vehicle''s drive method.
}

Como ambas funciones derivadas de la clase BMW tienen la misma plantilla, la llamada b.drive resultará en un error de compilación. Por lo tanto, para especificar qué unidad () queremos, usamos el operador :: .

3. Para anular la función anulada.

El operador de resolución de ámbito binario ayuda a llamar a la función de la clase base que se invalida en una clase derivada utilizando el objeto de la clase derivada. Vea el código a continuación:

#include <iostream>
using namespace std;
class Car
{
public:
void drive()
{
cout << "I am driving Car./n";
}
};
class BMW : public Car
{
public:
void drive()
{
cout << "I am driving BMW/n";
}
};
int main(int argc, char** argv)
{
BMW b;
b.drive(); // Will call BMW''s drive function.
b.Car::drive(); // Will call Car''s drive function.
}

4. Para acceder a los miembros de datos estáticos.

Como sabemos, los miembros de datos estáticos son compartidos por clase por los objetos de esa clase. Por lo tanto, no deberíamos (aunque podamos) usar objetos para definir las variables estáticas. Vea el siguiente código:

#include <iostream>
using namespace std;
class Car
{
public:
static int car_variable;
};
int Car :: car_variable;
int main(int argc, char** argv)
{
Car :: car_variable = 10;
cout << "Car variable: " << Car :: car_variable << ''/n'';
return 0;
}