Scope Resolution Operator in C++

In C++, the scope resolution operator (::) is used to access the identifiers such as variable names and function names defined inside some other scope in the current scope. Let's take a look at an example:

#include <iostream>

int main() {

  	// Accessing cout from std namespace using scope
  	// resolution operator
    std::cout << "GeeksforGeeks";

    return 0;
}

GeeksforGeeks

Explanation: The std namespace contains the declaration of cout. So, to use cout, we first need to tell the compiler that it is declared inside the std namespace which is done using ::. The compiler then resolves the cout from there.

Syntax

The scope resolution operator follows this general syntax:

scope_name :: identifier

where scope_name is the name of the scope where identifier is defined.

Applications of Scope Resolution Operator

Following are the main applications of scope resolution operator illustrated with an example:

Accessing Global Variables

When a local variable shadows a global variable, meaning both have the same name, we can use the scope resolution operator :: to access the global variable.

#include <iostream>
using namespace std;

// Global x
int x = 3;

int main() {
  	
  	// Local x
    int x = 10;
  
  	// Printing the global
  	// variable x
    cout << ::x;
    return 0;
}

3

Namespace Resolution

It is also used to access the identifier such variables, functions and classes declared inside namespaces.

#include <bits/stdc++.h>
using namespace std;

// A sample namespace with 
// a variable
namespace N {
  	int val = 10;
};

int main() {
  
  	// Accessing val from 
  	// namespace N
    cout << N::val;
  	return 0;
}

10

Iterator Declaration

We use the scope resolution operator when declaring an iterator.

#include <bits/stdc++.h>
using namespace std;

int main() {
    vector<int> arr = {1, 2, 3, 4, 5};

    // Defining an iterator pointing to
    // the beginning of the vector
    vector<int>::iterator first =
    arr.begin();
      
    cout << *first;
    return 0;
}

1

Define Class Member Function Outside Class

The scope resolution operator :: allows us to define a member function of a class outside the class definition.

#include <iostream>
using namespace std;

// A sample class
class A {
public:
  
    // Only declaration of 
    // member function
    void fun();
};

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

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

fun() called

Access Class's Static Members

Static members of a class can be accessed without creating the object of the class. It is possible to access them using scope resolution operator.

#include<iostream>
using namespace std;

class A {
public:
    static int x; 
};

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

int main() {
    
  	// Accessing static data member
  	cout << A::x;
    return 0;
}

1

Refer to Base Class Member in Derived Class

The scope resolution operator can also be used to refer to the members of base class in a derived class especially if they have the same name.

#include <bits/stdc++.h>
using namespace std;

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

class Derived : public Base {
public:
  
  	// Overridden function
    void func() {
        cout << "Derived class func()" 
             << endl;
    }
};

int main() {
    Derived obj;
  
  	// Calling base class's func() from 
  	// the object of derived class
    obj.Base::func();
    obj.func();
    return 0;
}

Base class func()
Derived class func()

Can Scope Resolution Operator be Overloaded?

Since the scope resolution operator (::) is important in how C++ handles variables, functions and classes, it cannot be overloaded. When the program is compiled, the compiler needs to know the purpose of every name it sees. Unlike other operators, :: lets you access global variables, classes and namespaces. If programmers could customize ::, it would bring much confusion and make the overall language approximately not secure and simple. Therefore, the scope resolution operator cannot be overloaded in C++.

kartik

Follow

Improve

Article Tags :

• C++

Practice Tags :

• CPP