In C++, class is a user-defined data type that serves as a blueprint for creating objects. It encapsulates data for the object and functions that operate on that data. Classes provide a way to model real world entities and represent their properties and behaviors.

Example:

#include<iostream>
#include<string>
using namespace std;
class Employee
{

    string name;
    int emp_id;
    public:
    void get_info ( int n , string s )
    {
        emp_id = n;
        name = s;
    }
    
    void display_info()
    {
        cout << " Name = " << name << endl;
        cout << " ID = " << emp_id;
    }

};

int main()
{

    int id;
    string str;
    cout << " Enter emp id and name " << endl;
    cin >> id >> str;
    Employee e;
    e.get_info ( id , str) ;
    e.display_info();

}


Constructors in C++

A constructor is a special member function whose name is same as the name of its class in which it is declared and defined. 
The purpose of the constructor is to initialize the objects of the class.
The constructors are always declared in the public section.
They are invoked automatically when objects of the class are created.
They do not have any return type not even void so they cannot return any value.

Types:

1. Default Constructor
2. Parameterized Constructor
3. Copy Constructor


Example:

#include<iostream>
using namespace std;
class demo
{
    int data;
    public:
    demo() //default constructor called
    {
        data=0;
        cout<<data<<endl;
    }
    demo( int x ) //parameterized constructor called
    {
         cout << x << endl;   
    }
          
    demo(demo &d) //copy constructor called
    {
        data=d.data;
        cout<<data<<endl;

    }
};
int main()
{
    demo d1;
    demo d2( 10 );
    demo d3=d1;
}

Output:
0
10
0

Destructor 

A destructor is a member function of the class whose name is same as the name of the class but the preceded with tilde sign (~). 
The purpose of destructor is to destroy the object when it is no longer needed or goes out of scope.
Destructor is automatically called as soon as an object goes out of scope
Destructor can never take any arguments.
There is no explicit or implicit category for a destructor
Similar to constructor there is no return type for destructor and that’s why they cannot return any value.

Example:

#include <iostream.h>
class demo
{
    public :
    demo( )
    {
            cout << “ Constructor called\n ”;
    }
    ~demo( )
    {
            cout << “ Destructor called ” << endl;
    }
};
void main( )
{
    demo d;
}

OUTPUT:
Constructor called
Destructor called


Abstract class 

By definition, a C++ abstract class must include at least one pure virtual function
You cannot make an object of the abstract class type. However, pointers and references can be used to abstract class types. When developing an abstract class, define at least one pure virtual feature. A virtual function is declared using the pure specifier (= 0) syntax.


#include<iostream>
using namespace std;
class base     //abstract class since it comprises of a pure virtual function
{
    public:
    virtual void display() {}
};
class derived : public base
{
    public:
    void display()
    {
        cout<<"Derived class";
    }
};
int main()
{
    base *bptr;
    derived d;
    bptr=&d;
    
    bptr->display();
}