Componente.h
#ifndef COMPONENTE_H
#define COMPONENTE_H
#include "data.h"
#include <string>
class Componente //classe astratta (virtuale pura)
{
private:
std::string produttore;
Data data_produzione;
public:
Componente(std::string ="sconosciuto", const Data& =Data(1,12,2000));
virtual ~Componente();
virtual void getInfo() const =0;
virtual Componente* clona() const =0;
};
#endif // COMPONENTE_H
componente.cpp
#include "componente.h"
#include <iostream>
Componente::Componente(std::string pr, const Data& dt): produttore(pr) , data_produzione(dt){}
Componente::~Componente(){}
void Componente::getInfo() const {
std::cout<<"produttore = "<<produttore<<std::endl<<"data di produzione = "<<data_produzione<<std::endl;
std::cout<<" il mio indirizzo e': "<<this;
std::cout<<std::endl;
}
alimentatore.h
#ifndef ALIMENTATORE_H
#define ALIMENTATORE_H
#include "componente.h"
#include <string>
#include <iostream>
class Alimentatore: public Componente
{
public:
Alimentatore(std::string , const Data&);
virtual Alimentatore* clona() const=0;
virtual ~Alimentatore();
};
#endif // ALIMENTATORE_H
alimentatore.cpp
#include "alimentatore.h"
Alimentatore::Alimentatore(std::string prod, const Data& dt): Componente(prod, dt) {}
Alimentatore::~Alimentatore() {}
carburatore.h
#ifndef CARBURATORE_H
#define CARBURATORE_H
#include "alimentatore.h"
class Carburatore: public Alimentatore
{
public:
Carburatore(std::string, const Data&);
void getInfo() const;
Carburatore* clona() const;
};
#endif // CARBURATORE_H
carburatore.cpp
#include "carburatore.h"
Carburatore::Carburatore(std::string prod, const Data & dt):Alimentatore(prod, dt){}
Carburatore* Carburatore::clona() const{
return new Carburatore(*this);
}
void Carburatore::getInfo() const{
Componente::getInfo();
std::cout<<"CARBURATORE";
}
iniettore.h
#ifndef INIETTORE_H
#define INIETTORE_H
#include "alimentatore.h"
class Iniettore: public Alimentatore
{
public:
enum modalita_iniezione {elettronica, meccanica, mista};
Iniettore(modalita_iniezione , std::string, const Data&);
void getInfo() const;
Iniettore* clona() const;
private:
modalita_iniezione tipo_iniettore; //1 elettr, 2 meccanico, 3 misto
};
#endif // INIETTORE_H
iniettore.cpp
#include "iniettore.h"
Iniettore::Iniettore(modalita_iniezione tp, std::string prod, const Data& dt):
Alimentatore(prod, dt), tipo_iniettore(tp){}
void Iniettore::getInfo() const {
Componente::getInfo();
std::cout<<"INIETTORE"<<std::endl;
if (tipo_iniettore==elettronica) std::cout<<"elettronico"<<std::endl;
if (tipo_iniettore==meccanica) std::cout<<"meccanico"<<std::endl;
if (tipo_iniettore==mista) std::cout<<"misto"<<std::endl;
}
Iniettore* Iniettore::clona() const{
return new Iniettore(*this);
}
motore.h
#ifndef MOTORE_H
#define MOTORE_H
#include <iostream>
#include "componente.h"
class Motore: public Componente //deve essere una classe astratta (deve avere dei metodi puri)
{
friend std::ostream& operator<< (std::ostream&, const Motore&);
private:
int n_cilindri;
int cilindrata; //espresso in cc
double rapporto_di_compressione; // espressa in kW
double coppia_massima; // espressa in Nm
bool sovralimentato; // true indica se il motore lo è, se false è ASPIRATO
//requisiti legali di conversione a GPL
static int min_cilindrataGPL_aspirato;
static int max_cilindrataGPL_aspirato;
static int min_cilindrataGPL_sovralimentato;
static int max_cilindrataGPL_sovralimentato;
public:
//non voglio costruttore a 0 parametri in quanto non posso definire un motore standard
Motore(int , int, double, double, bool, std::string, const Data&);
int getN_cilindri() const;
int getCilindrata() const;
double getRapporto_compressione() const;
double getCoppia_max() const;
bool isSovralimentato() const;
void setN_cilindri(int);
void setCilindrata(int);
void setRapporto_compressione(double);
void setCoppia_max(double);
void setSovralimentato(bool);
bool idoneitaGPL() const; //se ci sono diversi requisiti di idoneità magari si fa polimorfa pura
void getInfo() const;
Motore* clona() const;
};
std::ostream& operator<< (std::ostream&, const Motore&);
#endif // MOTORE_H
motore.cpp
#include "motore.h"
#include "componente.h"
Motore::Motore(int n_c, int cil, double r_d_c, double cop_max, bool turbo, std::string prod, const Data & dt_prod):
n_cilindri(n_c), cilindrata(cil), rapporto_di_compressione(r_d_c),
coppia_massima(cop_max), sovralimentato(turbo), Componente(prod, dt_prod) {}
int Motore::min_cilindrataGPL_aspirato=890;
int Motore::max_cilindrataGPL_aspirato=5500;
int Motore::min_cilindrataGPL_sovralimentato=1335;
int Motore::max_cilindrataGPL_sovralimentato=2250;
Motore* Motore::clona() const{
return new Motore(*this);
}
int Motore::getN_cilindri() const {return n_cilindri;}
int Motore::getCilindrata() const {return cilindrata;}
double Motore::getRapporto_compressione() const {return rapporto_di_compressione;}
double Motore::getCoppia_max() const {return coppia_massima;}
bool Motore::isSovralimentato() const {return sovralimentato;}
void Motore::setN_cilindri(int n_c) {n_cilindri=n_c;}
void Motore::setCilindrata(int cc){cilindrata=cc;}
void Motore::setRapporto_compressione(double kW){rapporto_di_compressione=kW;}
void Motore::setCoppia_max(double Nm){coppia_massima=Nm;}
void Motore::setSovralimentato(bool turbo){sovralimentato=turbo;}
bool Motore::idoneitaGPL() const{
if (isSovralimentato())
return (cilindrata>=min_cilindrataGPL_sovralimentato &&
cilindrata<=max_cilindrataGPL_sovralimentato ? true : false);
else
return (cilindrata>=min_cilindrataGPL_aspirato &&
cilindrata<=max_cilindrataGPL_aspirato ? true : false);
}
void Motore::getInfo() const{
Componente::getInfo();
std::cout<<"MOTORE:"<<std::endl;
std::cout<<"cilindrata = "<<cilindrata<<" cc, n cilindri = "<<n_cilindri<<std::endl;
std::cout<<"rapporto di compressione = "<<rapporto_di_compressione<<" kW, coppia max = "<<coppia_massima<<" Nm"<<std::endl;
std::cout<<(sovralimentato ? "sovralimentato (turbo)" : "aspirato");
std::cout<<std::endl;
}
//funzioni esterne
std::ostream& operator << (std::ostream& canale, const Motore& o){
canale<<"MOTORE:"<<std::endl;
canale<<"cilindrata = "<<o.cilindrata<<" cc, n cilindri = "<<o.n_cilindri<<std::endl;
canale<<"rapporto di compressione = "<<o.rapporto_di_compressione<<" kW, coppia max = "<<o.coppia_massima<<" Nm"<<std::endl;
canale<<(o.sovralimentato ? "sovralimentato (turbo)" : "aspirato");
return canale;
}