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.

Declaring a constructor with arguments hides the compiler generated constructor. After this we cannot invoke the compiler generated constructor.

B # 0
I # 1
G # 1

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.

When the initial values are provided during runtime then it is called dynamic initialization.
Example to illustrate dynamic initialization
#include < iostream >
using namespace std;
class X
{
int n;
float avg;
public;
X(int p,float q)
{
n=p;
avg=q;
}
void disp( )
{
cout << "\n Roll number:-"<< n;
cout << "\nAverage:-"<< avg;
}
};
int main( )
{
int a; float b;
cout<< "\nEnter the Roll number";
cin >> a;
cout << "\nEnter the Average";
cin >> b;
X x(a,b);\\dynamic initialization
x.disp( );
return 0;
}
Output:
Enter the Roll Number 1201
Enter the Average 98.6
Roll number:- 1201
Average:- 98.6

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.