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:
// 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.
// 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.
// 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.
// 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
#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
// 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.
// 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
Contact Us