Scope resolution operator in C++

In C++, the scope resolution operator is ::. It is used for the following purposes.

1) To access a global variable when there is a local variable with same name:

CPP

// C++ program to show that we can access a global variable
// using scope resolution operator :: when there is a local 
// variable with same name 
#include<iostream> 
using namespace std;

int x; // Global x

int main()
{
int x = 10; // Local x
cout << "Value of global x is " << ::x;
cout << "\nValue of local x is " << x; 
return 0;
}

Output

Value of global x is 0
Value of local x is 10

2) To define a function outside a class.

CPP

// C++ program to show that scope resolution operator :: is
// used to define a function outside a class
#include <iostream>
using namespace std;

class A {
public:
    // Only declaration
    void fun();
};

// Definition outside class using ::
void A::fun() { cout << "fun() called"; }

int main()
{
    A a;
    a.fun();
    return 0;
}

Output

fun() called

3) To access a class’s static variables.

CPP

// C++ program to show that :: can be used to access static
// members when there is a local variable with same name
#include<iostream>
using namespace std;

class Test
{
    static int x; 
public:
    static int y; 

    // Local parameter 'x' hides class member
    // 'x', but we can access it using ::
    void func(int x) 
    { 
    // We can access class's static variable
    // even if there is a local variable
    cout << "Value of static x is " << Test::x;

    cout << "\nValue of local x is " << x; 
    }
};

// In C++, static members must be explicitly defined 
// like this
int Test::x = 1;
int Test::y = 2;

int main()
{
    Test obj;
    int x = 3 ;
    obj.func(x);

    cout << "\nTest::y = " << Test::y;

    return 0;
}

Output

Value of static x is 1
Value of local x is 3
Test::y = 2

4) In case of multiple Inheritance: If the same variable name exists in two ancestor classes, we can use scope resolution operator to distinguish. 

CPP

// Use of scope resolution operator in multiple inheritance.
#include<iostream>
using namespace std;

class A
{
protected:
    int x;
public:
    A() { x = 10; }
};

class B
{
protected:
    int x;
public:
    B() { x = 20; }
};

class C: public A, public B
{
public:
void fun()
{
    cout << "A's x is " << A::x;
    cout << "\nB's x is " << B::x;
}
};

int main()
{
    C c;
    c.fun();
    return 0;
}

Output

A's x is 10
B's x is 20

5) For namespace If a class having the same name exists inside two namespaces we can use the namespace name with the scope resolution operator to refer that class without any conflicts

C++

#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define nline "\n"

// Global Declarations

string name1 = "GFG";
string favlang = "python";
string companyName = "GFG_2.0";

// You can also do the same thing in classes as we did in
// our struct example

class Developer {
public:
    string name = "krishna";
    string favLang = "c++";
    string company = "GFG";

    // Accessing Global Declarations

    Developer(string favlang, string company)
        : favLang(favlang)
        , company(companyName)
    {
    }
};

int main()
{
    Developer obj = Developer("python", "GFG");
    cout << "favourite Language : " << obj.favLang << endl;
    cout << "company Name : " << obj.company << nline;
}

Output

favourite Language : python
company Name : GFG_2.0

6) Refer to a class inside another class: If a class exists inside another class we can use the nesting class to refer the nested class using the scope resolution operator

CPP

// Use of scope resolution class inside another class.
#include <iostream>
using namespace std;

class outside {
public:
    int x;
    class inside {
    public:
        int x;
        static int y;
        int foo();
    };
};
int outside::inside::y = 5;

int main()
{
    outside A;
    outside::inside B;
}

7) Refer to a member of the base class in the derived object: In the case of having the same method in both the base and derived classes, we could refer to each by the scope resolution operator as below.

C++

// Refer to a member of the base class in the derived object.
#include <iostream>

class Base {
public:
    void func()
    {
        std::cout << "This is Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void func()
    {
        std::cout << "This is Derived class" << std::endl;
    }
};

int main()
{
    Derived obj;
    obj.Base::func();
    obj.func();
    return 0;
}

Output

This is Base class
This is Derived class