Hierarquia de herança de pacote. Os serviços de entrega de pacotes, como FedEx®, DHL® e UPS®, oferecem uma série de opções diferentes de entrega, cada uma com custos específicos. Crie uma hierarquia de herança que represente os diversos tipos de pacotes. Use Pacote como classe-base da hierarquia, e depois inclua as classes PacoteDoisDias e PacoteNoturno que derivem de Pacote. A classe-base Pacote deverá incluir dados-membro que representem nome, endereço, cidade, estado e CEP do remetente e do destinatário do pacote, além de dados-membro que armazenam o peso (em gramas) e o custo por grama para enviar o

pacote. O construtor do Pacote deverá inicializar esses dados-membro. Cuide para que o peso e o custo por grama contenham valores positivos. O Pacote deverá fornecer uma função-membro public calculaCusto que retorne um double indicando o custo associado à remessa do pacote. A função calculaCusto de Pacote deverá determinar o custo multiplicando o peso pelo

custo por grama. A classe derivada PacoteDoisDias deverá herdar a funcionalidade da classe-base Pacote, mas também deverá incluir um dado-membro que represente um valor fixo cobrado pela empresa para prestar um serviço de entrega em dois dias. O construtor

de PacoteDoisDias deverá receber um valor para inicializar esse dado-membro. PacoteDoisDias

deverá redefinir a função-membro calculaCusto de modo que calcule o custo da entrega somando o valor fixo ao custo baseado no peso, calculado pela função calculaCusto do Pacote. A classe PacoteNoturno deverá herdar diretamente da classe Pacote e conter um dado-membro adicional que represente uma taxa adicional por grama cobrada para o serviço de entrega noturna. PacoteNoturno deverá redefinir a função--membro calculaCusto de modo que some a taxa adicional por grama ao custo-padrão por grama antes de calcular o custo da entrega. Escreva um programa de teste que crie objetos de cada tipo de Pacote e teste a função-membro calculaCusto.

Passo 1

Vamos criar uma hierarquia de pacotes. Começando pela classe base Package, que conterá as informações básicas do pacote e a forma de calcular o custo de envio padrão do pacote. Em seguida, derivaremos duas classes da classe Package. As classes derivadas implementarão diferentes abordagens para calcular o custo de envio do pacote.

Vamos começar com a classe base Package.

A classe contém um construtor padrão, funções getter e setter (funções de setter de membro de dados de peso e custo por onça têm validações) e a função de cálculo de custo de envio:

Aqui o arquivo de cabeçalho "Package.h":

#ifndef H_PACKAGE_H

#define H_PACKAGE_H

#include string>

using namespace std;

struct Address {

string name;

string address;

string city;

string state;

string ZIP;

};

class Package {

public:

Package(const Address &sender,

const Address &recipient,

double weight, double costPerOunce);

const string &getSenderName() const;

void setSenderName(const string &senderName);

const string &getSenderAddress() const;

void setSenderAddress(const string &senderAddress);

const string &getSenderCity() const;

void setSenderCity(const string &senderCity);

const string &getSenderState() const;

void setSenderState(const string &senderState);

const string &getSenderZip() const;

void setSenderZip(const string &senderZip);

const string &getRecipientName() const;

void setRecipientName(const string &recipientName);

const string &getRecipientAddress() const;

void setRecipientAddress(

const string &recipientAddress);

const string &getRecipientCity() const;

void setRecipientCity(const string &recipientCity);

const string &getRecipientState() const;

void setRecipientState(const string &recipientState);

const string &getRecipientZip() const;

void setRecipientZip(const string &recipientZip);

double getWeight() const;

void setWeight(double weight);

double getCostPerOunce() const;

void setCostPerOunce(double costPerOunce);

double calculateCost() const;

private:

Address sender;

Address recipient;

double weight;

double costPerOunce;

};

Passo 2

Agora, vamos implementar a classe no arquivo fonte "Package.cpp".

O construtor junto com o cabeçalho do arquivo:

#include "Package.h"

Package::Package(const Address &sender,

const Address &recipient,

double weight, double costPerOunce)

: sender(sender),

recipient(recipient)

{

setWeight(weight);

setCostPerOunce(costPerOunce);

}

...

As implementações das funções getter e setter:

const string &Package::getSenderName() const {

return sender.name;

}

void Package::setSenderName(const string &senderName) {

sender.name = senderName;

}

const string &Package::getSenderAddress() const {

return sender.address;

}

void Package::setSenderAddress(

const string &senderAddress) {

sender.address = senderAddress;

}

const string &Package::getSenderCity() const {

return sender.city;

}

void Package::setSenderCity(const string &senderCity) {

sender.city = senderCity;

}

const string &Package::getSenderState() const {

return sender.state;

}

void Package::setSenderState(const string &senderState) {

sender.state = senderState;

}

const string &Package::getSenderZip() const {

return sender.ZIP;

}

void Package::setSenderZip(const string &senderZip) {

sender.ZIP = senderZip;

}

const string &Package::getRecipientName() const {

return recipient.name;

}

void Package::setRecipientName(

const string &recipientName) {

recipient.name = recipientName;

}

const string &Package::getRecipientAddress() const {

return recipient.address;

}

void Package::setRecipientAddress(

const string &recipientAddress) {

recipient.address = recipientAddress;

}

const string &Package::getRecipientCity() const {

return recipient.city;

}

void Package::setRecipientCity(

const string &recipientCity) {

recipient.city = recipientCity;

}

const string &Package::getRecipientState() const {

return recipient.state;

}

void Package::setRecipientState(

const string &recipientState) {

recipient.state = recipientState;

}

const string &Package::getRecipientZip() const {

return recipient.ZIP;

}

void Package::setRecipientZip(

const string &recipientZip) {

recipient.ZIP = recipientZip;

}

Peso e custo por onça setter de membro de dados e implementações de função getter:

double Package::getWeight() const {

return weight;

}

void Package::setWeight(double weight) {

Package::weight = weight >= 0 ? weight : 0;

}

double Package::getCostPerOunce() const {

return costPerOunce;

}

void Package::setCostPerOunce(double costPerOunce) {

Package::costPerOunce = costPerOunce > 0 ?

costPerOunce : 0;

}

Passo 3

A implementação da função calculateCost():

double Package::calculateCost() const {

return weight * costPerOunce;

}

Agora, vamos derivar a classe TwoDayPackage da classe Package.

Herdaremos publicamente da classe base, adicionando o membro de dados flatFee e uma função calculateCost() substituída:

#ifndef H_TWODAYPACKAGE_H

#define H_TWODAYPACKAGE_H

#include "Package.h"

class TwoDayPackage : public Package {

public:

TwoDayPackage(const Address &sender,

const Address &recipient, double weight,

double costPerOunce, double flatFee);

double getFlatFee() const;

void setFlatFee(double flatFee);

double calculateCost() const;

private:

double flatFee;

};

#endif

Implementação de classe (para chamar funções da classe pai, use o operador de resolução de escopo):

#include "TwoDayPackage.h"

TwoDayPackage::TwoDayPackage(const Address &sender,

const Address &recipient,

double weight,

double costPerOunce,

double flatFee)

: Package(sender,

recipient,

weight,

costPerOunce),

flatFee(flatFee) {}

double TwoDayPackage::getFlatFee() const {

return flatFee;

}

void TwoDayPackage::setFlatFee(double flatFee) {

TwoDayPackage::flatFee = flatFee;

}

double TwoDayPackage::calculateCost() const {

return Package::calculateCost() + flatFee;

}

Passo 4

Implementação de classe (para chamar funções da classe pai, use o operador de resolução de escopo):

#include "OvernightPackage.h"

OvernightPackage::OvernightPackage(

const Address &sender,

const Address &recipient,

double weight,

double costPerOunce,

double additionalFee)

: Package(sender, recipient,

weight, costPerOunce),

additionalFee(additionalFee) {}

double OvernightPackage::getAdditionalFee() const {

return additionalFee;

}

void OvernightPackage::setAdditionalFee(

double additionalFee) {

OvernightPackage::additionalFee = additionalFee;

}

double OvernightPackage::calculateCost() const {

return (Package::getCostPerOunce() + additionalFee)

* Package::getWeight();

}

O arquivo principal para fins de demonstração:

#include iostream>

#include "TwoDayPackage.h"

#include "OvernightPackage.h"

using namespace std;

int main()

{

Package package({"Phil Jones", "3476 Bryan Street",

"Dallas", "Texas", "39870"},

{"Jay Myers", "2191 Chicago Avenue",

"Chicago", "Illinois", "60622"},

3.5, 0.55);

TwoDayPackage twoDayPackage(

{"Phil Jones", "3476 Bryan Street",

"Dallas", "Texas", "39870"},

{"Jay Myers", "2191 Chicago Avenue",

"Chicago", "Illinois", "60622"},

3.5, 0.55, 5);

OvernightPackage overnightPackage(

{"Phil Jones", "3476 Bryan Street",

"Dallas", "Texas", "39870"},

{"Jay Myers", "2191 Chicago Avenue",

"Chicago", "Illinois", "60622"},

3.5, 0.55, 0.1);

cout package.calculateCost() endl

twoDayPackage.calculateCost() endl

overnightPackage.calculateCost() endl;

}

Resposta

Ver desenvolvimento.