What are local class and global class in C++

In C++, a class is a fundamental block that achieves object-oriented programming. The class holds its data members and member functions. Objects help to access the data elements and functions. Objects are also called instances of the class. A class in C++ is referred to as a blueprint of an object.

Let us understand the definition of a class with a real-world example.

Example 1

Consider a class that contains bikes. There are many brands of bikes, such as Honda, Suzuki, Royal Enfield, etc. All these have some common attributes: bikes are 2-wheeled vehicles and have handles and mileage range. Etc. Here the brands are objects of the class bike.

Syntax

class Classname{
//block of code
};

In C++, the class keyword represents classes.

Global class

In C++, a class declared(defined) outside the body of a program's functions is referred to as a global class.

In simple words, a class definition occurring outside the body of all the functions is the global class.

Within the program body, the objects of the global class are declared at any desired place. Global class is the everywhere accessible class.

Syntax

class Global// Global class
{
      public:
      void gfunc()  //function
      {
          cout<<"global class \n";  //function body
      }
}obj;  //object 

1) Program code for Global class in C++

#include <iostream>
using namespace std;
class Global   // Global class
{
      public:
      void gfunc() // this is the global function
      {
          cout<<"global class \n"; //function body(prints “global class” as output)
      }
}obj; // obj is the global object


int main()
{
 obj.gfunc();
return 0;
}

Output

global class

Explanation

In the above program, a global object, "obj", is created to access the global function through a global class. Here the global class has the name “Global”. The global class “Global” contains the function gfunc(); this function prints "global class" as the output on the output screen. The global class is accessed through the object from the main function of C++.

2) Program code for Global class in C++

#include <iostream>
using namespace std;
class Global   // Global class
{
      public:
      void gfunc() // this is the global function
      {
          cout<<"global class \n"; //function body(prints “global class” as output)
      }
};


int main()
{
 Global object; // object is created from the main function
object.gfunc(); //function “gfunc()” accessed through the global class
return 0;
}

Output

global class

Explanation

The above program creates a global object "object" to access the global function through a global class. Here the global class has the name "Global". The global class "Global" contains the function “gfunc()”; this function prints "global class" as the output on the output screen. The object is directly created in the main function, and the function "gfunc()” is accessed through the object of the global class.

The objects of global classes can be created anywhere, even in the main function.

Local class

In C++, a class declared(defined) inside the body of any program function is referred to as a local class.

In simple words, a class definition occurring inside the body of a function is the local class.

The objects of the local class cannot be declared everywhere, and the local objects have their scope limited to that particular local class only. The local classes cannot be accessed outside the function.

Syntax

void fun()  // function name “fun”
{
     class Local        // local class (class defined inside the function)
   {
       public:
       void lfunc()    // a function defined inside the local class
       {
           cout<<"local class \n";        // function body
       }     
   };
Local o;        //local object
o.lfunc();
}

Program code for Local class in C++

#include <iostream>
using namespace std;
void fun()      // function name “fun()
{
     class Local             // local class defined inside the function
   {
       public:
       void lfunc()    //function defined inside the local class.
       {
           cout<<"local class \n";   //function body
       }     
   };
Local o;  //object “o” (local class object)
o.lfunc();
}
int main()
{
fun();  //function call
return 0;
}

Output

local class

Explanation

In the above program, a local object “o” is created to access the local function “lfunc()” through a local class inside the function “fun()”. Here the local class has the name “Local”. The function “fun()” has the local class “Local” that contains the function lfunc(), this function prints “local class” as the output on the output screen. The local class is accessed through the object from the function “fun()” of the above program.

The local objects cannot be created in other functions; the compiler gives an error.

Example of global and local classes in C++

#include <iostream>
using namespace std;
class Global              // Global class name “Global”
{
      public:
      void gfunc()   // function “gfunc()”
      {
          cout<<"global class \n";  //function body
      }
}obj;  //object of the class “Global”
void fun()    //function “fun()”
{
     class Local    // local class defined inside the function “fun()”
   {
       public:
       void lfunc()  //function defined inside the local class
       {
           cout<<"local class \n";  //function body of “lfunc()”
       }     
   };
Local o;    //local object “o”
o.lfunc();
}
int main()
{
obj.gfunc();   
fun();
return 0;
}

Output

global class 
local class

Conclusion

A class declared outside all functions is global because the objects can be created everywhere (at any desired block) in the program. If a class is declared within a function body, it is referred to as a local class because objects of this class are local to its defined function.