Interfacce , overriding ed ereditarietà in C++

Nello standard 2011 l’interfaccia in C++ viene implementata attraverso una classe astratta. Una classe si dice astratta se contiene almeno un metodo virtuale puro. Un metodo virtuale puro è un metodo che si definisce nel seguente modo: virtual int metodo() =0;

Le classi che derivano da una classe astratta devono implementare tutti i metodi virtuali della classe astratta.

#include<iostream>

#include<cmath>

using namespace std;



class punto
{

     public:
    
     double x,y;

     punto()
     {

      x=0;
      y=0;
    
     }

     punto(int x, int y)
     {

      this->x=x;
      this->y=y;

     }
  
     /*costruttore di copia che si aziona quando si copiano due punti ( es punto a=b)

       deve essere implementato, altrimentio di default copia gli indirizzi
     */
 
     punto(const punto& q) {

     this->x=q.x;
     this->y=q.y;


     }
     


};


/*Classe astratta o interfaccia */
class figura
{


   public:

   figura(){}


  virtual double area()=0;


  virtual double perimetro()=0;

  
  virtual void print()=0;
  

};



class rettangolo:public figura
{

   private:
 /*ordina in senso crescente l'array: metodo privato perche serve solo alla classe rettangolo*/
   void ordina(double a[], int dim)
   {

         int css=1;

         while(css)
        
         {

         css=0;
        	 for(int i=0;i<dim-1;i++)
       		 {
         		if(a[i]>a[i+1])
                        { 
                            double temp=a[i];
                            a[i]=a[i+1];
                            a[i+1]=temp;
			    css=1;
                           
                        }

        	 }
         

        }
   	
   	
   }

   public:

   int n;//numero di lati
   double base,h;
   punto **pt;

   //costruttore rettangolo di default 
   rettangolo()
   {
   
    n=4;
    pt=new punto*[n];
    
    pt[0]=new punto(0,0);
    pt[1]=new punto(0,1);
    pt[2]=new punto(1,0);
    pt[3]=new punto(1,1);
    base=1;
    h=1;

   }

  

   rettangolo(punto a, punto b, punto c, punto d)
   {
    

     n=4;
     pt=new punto*[n];
    
     pt[0]=new punto(a);
     pt[1]=new punto(b);
     pt[2]=new punto(c);
     pt[3]=new punto(d);
 
      
     /*devo cercare la base e l'altezza per cui i punti che non saranno mai  le diagonali*/
       
  
     double ab=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
     double bc=sqrt((b.x-c.x)*(b.x-c.x)+(b.y-c.y)*(b.y-c.y));
     double cd=sqrt((c.x-d.x)*(c.x-d.x)+(c.y-d.y)*(c.y-d.y));
     double da=sqrt((d.x-a.x)*(d.x-a.x)+(d.y-a.y)*(d.y-a.y));

     double ac=sqrt((a.x-c.x)*(a.x-c.x)+(a.y-c.y)*(a.y-c.y));
     double db=sqrt((d.x-b.x)*(d.x-b.x)+(d.y-b.y)*(d.y-b.y));
    
     /*la diagonale è il segmento più grande*/


     double segmenti[6]={ab,bc,cd,da,ac,db};
     ordina(segmenti,6);
     
    
     base=segmenti[1];
     h=segmenti[2];
     
     
   }
  
    double area() 
    {
     
    //area del rettangolo

    }

    double perimetro() 
    {

      //perimetro del rettangolo

    }

    void print()
    {  
       //stampa un rettangolo o un triangolo
    } 

};




class triangolo:public rettangolo
{
	
	
	
	/*cotruisce un triangolo facendo coincidere due vetici del rettangolo, costruito con il costruttore a parametri del rettangolo */
	public:
		triangolo(punto a, punto b, punto c):rettangolo(a,b,b,c)
		
		{
			
			
		
			
			
		}
	
	//overriding del metodo area
	double area() 
    {
     
     //area del triangolo

    }

    

	
	
	
};