Identify the error.
A a1;
X 1.5 = 1
A1. init ( ) ;}

If a class definition is specified outside the body of all functions in a program then it is called global class.

Public, private and protected are called access specifiers.

Class is a way to bind the data and its associated functions together.

The purpose of the destructor is to free the resources that the object may have acquired during its lifetime. A destructor function removes the memory of an object which was allocated by the constructor at the time of creating a object.

Class comprises of members. Members are classified as Data Members and Member functions. Data members are the data variables that represent the features or properties of a class. Member functions are the functions that perform specific tasks in a class.

A constructor that accepts no parameter is called default constructor. For example in the class data program Data :: Data ( ) is the default constructor. Using this constructor. objects are created similar to the way the variables of other data types are created.
Example
int num; // ordinary variable declaration
Data d1; // object declaration

The definition of a class only creates a new user defined data type. The instances of the class type should be instantiated (created and initialized). Instantiating object is done using constructor. An array or a structure in c++ can be initialized during the time of their declaration. The initialization of class type object at the time of declaration similar to a structure or an array is not possible because the class members have their associated access specifiers (private or protected or public). Therefore Classes include special member functions called as constructors. The constructor function initializes the class object.

A constructor having a reference to an already existing object of its own class is called copy constructor. In other words Copy Constructor is a type of constructor which is used to create a copy of an already existing object of a class type. It is usually of the form simple (simple &), where simple is the class name. The compiler provides a default Copy Constructor to all the classes.

When constructor and destructor are declared under public:
1. we can initialize the object while declaring it.
2. we can explicitly call the constructor.
3. we can overload constructors and therefore use multiple constructors to initialize objects automatically.
4. we can destroy the objects at the end of the class scope automatically (free unused memory). 
However, some C++ compilers and Dev C++ do not allow to declare constructor and destructors under private section. So it is better to declare constructor and destructor under public section only.

#include< iostream >
#include< conio >
using namespace std
class add //Global class
{
int a,b;
public;
int sum;
void getdata( )
{
a=5;
b=10;
sum=a+b;
}
} a1; //global object
add a2;  //global object
int main ( )
{
add a3; //Local object for a global class
a1.getdata( );
a2.getdata( );
a3.getdata( );
cout << a1.sum; //public data member accessed from outside the class
cout << a2.sum;
cout << a3.sum;
return 0;
}
Output:
151515

Constructor of class P
Constructor of class Q
Constructor of class R
Destructor of class R
Destructor of class Q
Destructor of class P

Nested class: When one class become the member of another class then it is called Nested class and the relationship is called containership.
Classes can be nested in two ways.
1. By defining a class within another class
2. By declaring an object of a class as a member to another class.
Defining a class with in another: When a class is declared with in another class, the inner class is called as Nested class (ie the inner class) and the outer class is known as Enclosing class. Nested class can be defined in private as well as in the public section of the Enclosing class.
C++ program to illustrate the nested class
#include < iostream >
using namespace std;
class enclose
{
private:
int x;
class nest
{
private:
int y;
public:
int z;
void prn ( )
{
y=3;z=2;
cout << "\n The product of'" << y << '*' << z << "=" << y*z << "\n";
}
}; //inner class definition over
nest n1;
public:
nest n2;
void square ( )
{
n2.prn ( ); //inner class member function is called by its object
x=2;
n2.z=4;
cout << "\n The product of " << n2.z << '*' << n2.
z << "=" << n2.z*n2.z << "\n";
cout << "\n The product of " << x << '*' << x << "=+ << x*x;
}
}; //outer class definition over
int main ( )
{
enclose e;
e.square ( ); // outer class member function is called
}
Output:
The product of 3*2=6
The product of 4*4=16
The product of 2*2=4
In the above program the inner class nest is defined inside the outer class enclose. nest is accessed by enclose by creating an objec of nest.