Classe abstrata EmissaoCarbono: polimorfismo. Usando uma classe abstrata com apenas funções virtuais puras, você pode especificar comportamentos semelhantes de classes possivelmente divergentes. Governos e empresas do mundo inteiro estão cada vez mais preocupadas com as emissões de carbono (liberações anuais de dióxido de carbono na atmosfera) de prédios que consomem vários tipos de combustíveis para obter calor, veículos que consomem combustíveis para obter potência, e coisas desse tipo. Muitos cientistas culpam esses gases do efeito estufa pelo fenômeno chamado aquecimento global. Crie três

classes pequenas não relacionadas por herança — classes Predio, Carro e Bicicleta. Dê a cada classe alguns atributos e comportamentos apropriados exclusivos que ela não tenha em comum com as outras classes. Escreva uma classe abstrata EmissaoCarbono com apenas um

método virtual puro retEmissaoCarbono. Faça com que cada uma de suas classes herde dessa classe abstrata e implemente o método retEmissaoCarbono para calcular uma emissão de carbono apropriada para essa classe (verifique em alguns sites que explicam como calcular a emissão de carbono). Escreva uma aplicação que crie objetos de cada uma das três classes, coloque ponteiros para esses objetos em um vetor de ponteiros EmissaoCarbono e

depois percorra o vetor, chamando polimorficamente o método retEmissaoCarbono de cada objeto. Para cada objeto, imprima informações de identificação e sua emissão de carbono.

Passo 1

Vamos criar um aplicativo que mede as pegadas de carbono de vários objetos. Cada objeto tem sua própria abordagem para calcular as emissões causadas por ele.

Pegada de carbono

A classe abstrata base (pai) que requer a função getCarbonFootprint():

#ifndef H_CARBONFOOTPRINT_H

#define H_CARBONFOOTPRINT_H

class CarbonFootprint {

public:

virtual double getCarbonFootprint() const = 0;

};

#endif

Passo 2

Construção

Esta classe terá a área (em pés quadrados) como sua propriedade única.

Para calcular as emissões de um edifício, precisamos saber quantas termas de gás natural o edifício consome (anualmente). Este valor é então multiplicado por um fator de 11,7, o que resulta em CO_2CO Em emissões em libras.

Declaração de classe:

#ifndef H_BUILDING_H

#define H_BUILDING_H

#include "CarbonFootprint.h"

class Building : public CarbonFootprint {

public:

Building(double area, double naturalGas);

double getArea() const;

void setArea(double area);

double getNaturalGasUsed() const;

void setNaturalGasUsed(double naturalGasUsed);

double getCarbonFootprint() const;

private:

double area;

double naturalGasUsed;

};

#endif

Passo 3

Fórmula da pegada de carbono para um edifício (t sendo as térmicas consumidas do gás natural):

c = t \ vezes 11,7

c=t×11,7

Implementação da classe:

#include "Building.h"

Building::Building(double area, double naturalGas) : area(

area), naturalGasUsed(naturalGas) {}

double Building::getArea() const {

return area;

}

void Building::setArea(double area) {

Building::area = area;

}

double Building::getNaturalGasUsed() const {

return naturalGasUsed;

}

void Building::setNaturalGasUsed(double naturalGasUsed) {

Building::naturalGasUsed = naturalGasUsed;

}

double Building::getCarbonFootprint() const {

return naturalGasUsed * 11.7;

}

Carro

Esta classe terá o tipo de gás como sua propriedade única. Também usaremos esse valor no cálculo da pegada de carbono.

Para calcular o CO_2CO

2

Em

emissões de um carro, multiplicaremos o gás usado (galões) pelo valor constante que representa o CO_2CO

2

Em

emissões da queima de um galão do tipo de gás de carro.

Declaração de classe:

#include "CarbonFootprint.h"

class Car : public CarbonFootprint {

public:

Car(char gasType, double gasUsed);

char getGasType() const;

void setGasType(char gasType);

double getGasUsed() const;

void setGasUsed(double gasUsed);

double getCarbonFootprint() const;

private:

char gasType;

double gasUsed;

const double DIESEL = 5.78;

const double PETROL = 5.27;

};

#endif

Fórmula da pegada de carbono para um carro (u sendo o gás usado em galões e G sendo a pegada de carbono de um tipo de gás (constante)):

c = u \vezes G

c=u×G

Implementação da classe:

#include "Car.h"

Car::Car(char gasType, double gasUsed)

: gasUsed(gasUsed)

{

if (gasType != 'D' && gasType != 'P')

gasType = 'P';

}

char Car::getGasType() const {

return gasType;

}

void Car::setGasType(char gasType) {

Car::gasType = gasType;

}

double Car::getGasUsed() const {

return gasUsed;

}

void Car::setGasUsed(double gasUsed) {

Car::gasUsed = gasUsed;

}

double Car::getCarbonFootprint() const {

return gasUsed * (gasType == 'D' ? DIESEL : PETROL);

}

Passo 4

Bicicleta

Esta classe terá o tipo de modelo como sua propriedade exclusiva.

Declaração de classe:

#ifndef H_BICYCLE_H

#define H_BICYCLE_H

#include

#include "CarbonFootprint.h"

using namespace std;

class Bicycle : public CarbonFootprint {

public:

Bicycle(const string &model);

const string &getModel() const;

void setModel(const string &model);

double getCarbonFootprint() const;

private:

string model;

};

#endif

Como as bicicletas não produzem nenhuma emissão de carbono, teremos a função getCarbonFootprint() retornando 0.

Implementação da classe:

#include "Bicycle.h"

Bicycle::Bicycle(const string &model) : model(model) {}

const string &Bicycle::getModel() const {

return model;

}

void Bicycle::setModel(const string &model) {

Bicycle::model = model;

}

double Bicycle::getCarbonFootprint() const {

return 0;

}

Principal

Cabeçalho do arquivo:

#include

#include

#include "Building.h"

#include "Car.h"

#include "Bicycle.h"

usando o namespace std;

...

Em primeiro lugar, declare alguns objetos e coloque-os em um vetor da seguinte forma:

int main()

{

Building building(12000, 800);

Car car('D', 562);

Bicycle bicycle("All-road");

vector objects;

objects.push_back(&building);

objects.push_back(&car);

objects.push_back(&bicycle);

...

}

Por fim, itere pelos objetos dentro do vetor, determinando seu tipo usando o valor de retorno da conversão dinâmica.

Cada vez que o tipo do objeto for encontrado, crie um objeto temporário do tipo correspondente para usar as funções necessárias.

int main()

{

...

for (auto & object : objects)

{

if (dynamic_cast(object))

{

auto* tmp = (Building*)object;

cout getArea()

cout

getCarbonFootprint()

}

else if (dynamic_cast(object))

{

auto* tmp = (Car*)object;

cout

getGasType() == 'D' ? "Diesel"

: "Petrol")

cout

getCarbonFootprint()

}

else

{

auto* tmp = (Bicycle*)object;

cout

getModel()

cout

getCarbonFootprint()

}

}

}

Resposta

Ver o desenvolvimento.