Para empezar, es necesario definir dos términos normalmente usados al tratar la herencia. Cuando una clase hereda otra, la clase que se hereda se llama clase base. La clase que hereda se llama clase derivada. La clase base  define todas las cualidades que serán comunes a cualquier clase derivada. Otro punto importante es el acceso a la clase base. El acceso a la clase base pude tomar 3 valores, public, private y protected.

Si el acceso es public, todos los atributos de la clase base son públicos para la derivada.

Si el acceso es private, los datos son privados para la clase base la derivada no tiene acceso.

Si el acceso es protected, datos privados para la base y derivada tiene acceso, el resto sin acceso.

EJEMPLO: para comprobar los distintos tipos de acceso.
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class miclase{
     int a;
protected:
     int b;
public:
     int c;
     miclase(int n,int m){a=n;b=m;}
     int obten_a(){return a;}
     int obten_b(){return b;}
};

void main()
{
     miclase objeto(10,20);
     clrscr();
     objeto.c=30;
     // objeto.b=30; error,sin acceso.
     // objeto.a=30; error,sin acceso.
     cout<<objeto.obten_a() <<"\n";
     cout<<objeto.obten_b() <<"\n";
     cout<<objeto.c;
     getch();
}

FORMATO DE LA CLASE DERIVADA:
class nombre_derivada:acceso nombre_base{
   cuerpo;
};

EJEMPLO: Herencia pública.
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class base{
     int x;
public:
     void obten_x(int a){x=a;}
     void muestra_x(){cout<< x;}
};

class derivada:public base{
     int y;
public:
     void obten_y(int b){y=b;}
     void muestra_y(){cout<<y;}
};

void main()
{
     derivada obj;
     clrscr();
     obj.obten_x(10);
     obj.obten_y(20);
     obj.muestra_x();
     cout<<"\n";
     obj.muestra_y();
     getch();
}

 EJEMPLO: Herencia con acceso privado.
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class base{
     int x;
public:
     void obten_x(int a){x=a;}
     void muestra_x(){cout<<x <<"\n";}
};

class derivada:private base{
     int y;
public:
     void obten_xy(int a,int b){obten_x(a);y=b;}
     void muestra_xy(){muestra_x();cout<<y<<"\n";}
};

void main()
{
     clrscr();
     derivada ob;
     ob.obten_xy(10,20);
     ob.muestra_xy();
     // ob.obten_x(10); error,sin acceso.
     // ob.muestra_x(); error,sin acceso.
     getch();
}

HERENCIA MULTIPLE: Existen dos métodos en los que una clase derivada puede heredar más de una clase base. El primero, en el que una clase derivada puede ser usada como la clase base de otra clase derivada, creándose una jerarquía de clases.  El segundo, es que una clase derivada puede heredar directamente más de una clase base. En esta situación se combinan dos o más clases base para facilitar la creación de la clase derivada.

SINTAXIS: Para construir la derivada mediante varias clases base.
class derivada:acceso nomb_base1,nomb_base2,nomb_baseN{
      cuerpo;
 };                  

SINTAXIS: Para crear herencia múltiple de modo jerárquico.
class derivada1:acceso base{
         cuerpo;
 };

     class derivada2:acceso derivada1{
         cuerpo;
     };

     class derivadaN:acceso derivada2{
         cuerpo;
     };

 EJEMPLO: Herencia de tipo jerárquica.
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class base_a{
     int a;
public:
     base_a(int x){a=x;}
     int ver_a(){return a;}
};

class deriva_b:public base_a{
     int b;
public:
     deriva_b(int x, int y):base_a(x){b=y;}
     int ver_b(){return b;}
};

class deriva_c:public deriva_b{
     int c;
public:
     deriva_c(int x,int y,int z):deriva_b(x,y){c=z;}
     void ver_todo()
     {
         cout<<ver_a()<<" "<<ver_b()<<" "<<c;
     }
};

void main()
{
     clrscr();
     deriva_c ob(1,2,3);
     ob.ver_todo();
     cout<<"\n";
     cout<<ob.ver_a()<<" "<<ob.ver_b();
     getch();
}

El caso de los constructores es un poco especial. Se ejecutan en orden descendente, es decir primero se realiza el constructor de la clase base y luego el de las derivadas. En las destructoras ocurre en orden inverso, primero el de las derivadas y luego el de la base.

 EJEMPLO: Múltiple heredando varias clases base.
#include <iostream.h>
#include <stdio.h>
#include <conio.h>
class B1{
     int a;
public:
     B1(int x){a=x;}
     int obten_a(){return a;}
};

class B2{
     int b;
public:
     B2(int x){b=x;}
     int obten_b(){return b;}
};

class C1:public B1,public B2{
     int c;
public:
     C1(int x,int y,int z):B1(z),B2(y)
     {
         c=x;
     }
     void muestra()
     {
         cout<<obten_a()<<" "<<obten_b()<<" ";
         cout<<c<<"\n";
     }
};

void main()
{
     clrscr();
     C1 objeto(1,2,3);
     objeto.muestra();
     getch();
}