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.