Comment accéder à une variable globale dans une portée locale?

Vous devriez être en utilisant ::x afin d'accéder à une variable globale dans une portée locale. L'opérateur :: est unaire opérateur de résolution de portée. Ainsi, votre code devrait être:

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

Remarque: :: opérateur a deux significations en C++:

1. Binaire opérateur de résolution de portée.
2. Unaire opérateur de résolution de Portée.

La quasi-totalité de votre codage heures, vous serait d'utiliser le Binaire opérateur de résolution de portée. Ainsi, bien que la réponse à cette question est unaire opérateur de résolution de portée; juste pour le plaisir de référence future, je enrôler certains cas d'utilisation typique de l'Binaire opérateur de résolution de portée.

Cas d'utilisation de la Binaire opérateur de résolution de portée:

1. Pour définir vos fonctions à l'extérieur de la classe.

Nous organiser notre code dans les fichiers d'en-tête avec .h extension et les fichiers de code .rpc extension. Alors que la définition de nos fonctions dans les fichiers de code, nous utilisons la :: Binaire opérateur de résolution de portée.

Par exemple,un Voiture.h fichier ressemble à ceci:

class Car
{
    private:
        int model;
        int price;

    public:
        void drive();
        void accelerate();
};

Et Car.cpp ressemblerait à:

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

Ici, comme on peut facilement constater, :: agit sur deux opérandes:

1. Le nom de la classe
2. Le nom de la fonction

Donc, essentiellement, il définit le champ d'application de la fonction c'est à dire qu'il informe le compilateur que la fonction voiture() appartient à la classe Voiture.

---

2. Pour résoudre l'ambiguïté entre les deux fonctions avec le même modèle qui sont issus de classes différentes.

Considérons le code suivant:

#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.
}

Comme à la fois les fonctions dérivées de la classe de BMW ont le même modèle, l'appel b.drive qui va provoquer une erreur de compilation. Ainsi, pour spécifier les voiture() nous voulons, nous utilisons la :: opérateur.

---

3. Pour remplacer le substituée fonction.

Binaire opérateur de résolution de portée permet d'appeler la fonction de la classe de base qui est redéfinie dans une classe dérivée à l'aide de la dérivée de la classe de l'objet. Voir le code ci-dessous:

#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. Pour accéder aux données membres statiques.

Comme nous le savons, les données membres statiques sont partagées par la classe de base par les objets de cette classe. Par conséquent, nous ne devrions pas (bien que nous le pouvons) utiliser des objets à la portée des variables statiques. Voir le code suivant:

#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;
}