Classe figura - Alessandro Barazzuol

Classe figura

figura.h

#ifndef FIGURA_H
#define FIGURA_H

#include "def.h"

using namespace std;

/*classe punto definita al momento*/
class punto
{
	public:
		double x,y;
		punto(double x, double y)
		{
			this->x=x;
			this->y=y;
		}
	   
};


/*Classe astratta figura: si definisce astratta una classe in cui è dichiarato almeno un metodo virtuale puro.*/
/*Gestisce figure al massimo di otto lati*/

class figura
{
	
	private:
		string wat();
	
	public:
		figura();
		figura(int nlati);
		~figura();
	
		/*metodo virtuale perchè ridefinito su triangolo_rettangolo*/
	    virtual string toString();
	   
	    
	    /*metodi astratti non serve implementarli in figura, ma è neccessario farlo nelle classi derivate*/
		virtual double area()  = 0;
		virtual double perimetro()  = 0;
		
		
		
		/*metodi classici*/
		int getNlati();
		string lati();
		
		/*metodi statici ausiliari*/
		static string ItoS(int n);
		static string DtoS(double n);
		static string inv(string s);
		
	protected:
		/*attributi protetti*/
		int nlati;
		/*array che contiene i lati delle figure*/
		double l[DIM];
};

#endif

figura.cpp

#include "figura.h"

using namespace std;

figura::figura()
{
	
}
figura::figura(int nlati)
{
	this->nlati=nlati;
}
string figura::wat()
{
	switch (nlati)
	{
		case 0:
			return "Cerchio";
		case 1:
			case 2:
			return "Segmento";
			case 3:
			return "Triangolo";
			case 4:
				return "Quadrilatero";
				case 5:
					return "Pentagono";
					case 6:
						return "Esagono";
						case 7:
						return "Ettagono";
						case 8:
							return "Ottagono";
							
							 default:
								return "Figura indefinita";
			
	}
}
int figura::getNlati()
{
	return nlati;
}

string figura::toString()
{
	
  return "Figura: "+ wat();
}
figura::~figura()
{
	
}



string figura::lati()
{
	string tmp="";
	for(int i=0;i<nlati;i++)
	tmp+= "Lati: "+DtoS(l[i])+" ";
	
	return tmp;
}


/*metodi statici ausiliari*/
/*metodo che converte un intero in stringa*/

	     string figura::ItoS(int n)
	    {
	    	string tmp;
	    	while(n>0)
	    	{
	    		tmp+=(char)(n%10+48);
	    		n/=10;
			}
			
			return inv(tmp);
		}
		
		
		/*metodo che converte un double in stringa*/
		 string figura:: DtoS(double n)
	    {
	    	string tmpdeci="";
	    	string tmp="";
	    	double dec=n-(int)n;
	    	int deci=100*dec;
	    	int intera=(int)n;
	    	
	    	while(deci>0)
	    	{
	    		tmpdeci+=(char)(deci%10+48);
	    		deci/=10;
			}
			if(tmpdeci=="")
			tmpdeci="00";
			while(intera>0)
	    	{
	    		tmp+=(char)(intera%10+48);
	    		intera/=10;
			}
			
			return inv(tmp) + "," + inv(tmpdeci);
			
		}
		
		
		
         string figura::inv(string s)
		{
			int i=0,j=s.length()-1;
			while(i<j)
			{
				swap(s[i],s[j]);
				i++;
				j--;
			}
			
			return s;
		}		
		
		

triangolo.h

#ifndef TRIANGOLO_H
#define TRIANGOLO_H

#include "figura.h"




class triangolo : public figura
{
	private:
		
	public:
		triangolo();
		triangolo(double a, double b, double c);
		~triangolo();
		virtual double area();
		virtual double perimetro();
	   
	protected:
};

#endif

triangolo.cpp

#include "triangolo.h"

triangolo::triangolo()
{
}
triangolo::triangolo(double a, double b, double c)
{
	nlati=3;
	l[0]=a;
	l[1]=b;
	l[2]=c;
}
triangolo::~triangolo()
{
	nlati=3;
	
}
double triangolo::area()
{
	double sp=perimetro()/2;
			
	return sqrt(sp*(sp-l[0])*(sp-l[1])*(sp-l[2]));
}
		
double triangolo::perimetro()
{
	return l[0]+l[1]+l[2];
}

def.h

/*header file dove includiamo tutte le librerie*/
#define DIM 8
#include<math.h>
#include<iostream>
#include<string>
#define PI 3.14

triangolo_rettangolo.h

#ifndef TRIANGOLO_RETTANGOLO_H
#define TRIANGOLO_RETTANGOLO_H

#include "triangolo.h"

class triangolo_rettangolo : public triangolo
{
	public:
		triangolo_rettangolo();
		~triangolo_rettangolo();
		triangolo_rettangolo(double b, double a);
		string toString();
		double area();
	protected:
};

#endif

triangolo_rettangolo.cpp

#include "triangolo_rettangolo.h"

triangolo_rettangolo::triangolo_rettangolo()
{
}
triangolo_rettangolo::triangolo_rettangolo(double b, double a):triangolo(b,a,sqrt(a*a+b*b))
{
//	nlati=3; non serve perche passa attraverso il costruttore di triangolo che ha gia nlati=3
	l[0]=b;
	l[1]=a;
	l[2]=sqrt(a*a+b*b);
	
}
triangolo_rettangolo::~triangolo_rettangolo()
{
}
/*overriding metodo toString*/
string triangolo_rettangolo::toString()
{
	return "Figura: Triangolo Rettangolo";
}
double triangolo_rettangolo::area(){
	
	return l[0]*l[1]/2;
}

triangolo_isoscele.h

#ifndef TRIANGOLO_ISOSCELE_H
#define TRIANGOLO_ISOSCELE_H

#include "triangolo.h"

class triangolo_isoscele : public triangolo
{
	public:
		triangolo_isoscele(double b, double h);
		triangolo_isoscele();
		~triangolo_isoscele();
		string toString();
	protected:
};

#endif

triangolo_isoscele.cpp

#include "triangolo_isoscele.h"

triangolo_isoscele::triangolo_isoscele()
{
}
triangolo_isoscele::triangolo_isoscele(double b, double h):triangolo(b,sqrt((b/2)*(b/2)+h*h),sqrt((b/2)*(b/2)+h*h))
{
	l[0]=b;
	l[1]=sqrt((b/2)*(b/2)+h*h);
	l[2]=l[1];
}
triangolo_isoscele::~triangolo_isoscele()
{
}

string triangolo_isoscele::toString()
{
	return "Figura: Triangolo isoscele";
}

cerchio.h

#ifndef CERCHIO_H
#define CERCHIO_H

#include "figura.h"

class cerchio : public figura
{
	public:
		cerchio();
		cerchio(double r, punto c);
		~cerchio();
		virtual double area();
		virtual double perimetro();
	protected:
};

#endif

cerchio.cpp

#include "cerchio.h"

cerchio::cerchio()
{
}

cerchio::~cerchio()
{
}

cerchio::cerchio(double r,punto c):figura(0)
{
	l[0]=r;
	
}
double cerchio::area()
{
	double sp=perimetro()/2;
			
	return PI*l[0]*l[0];
}
		
double cerchio::perimetro()
{
	return 2*PI*l[0];
}