Hierarquia de herança de Conta. Crie uma hierarquia de herança que pudesse ser usada por um banco para representar as contas bancárias dos clientes. Todos os clientes desse banco poderiam depositar (ou seja, creditar) dinheiro em suas contas e sacar (ou seja, debitar) dinheiro de suas contas. Também existiriam tipos mais específicos de contas. Contas-poupança, por exemplo, receberiam juros sobre o dinheiro mantido. Contas-correntes,

por outro lado, cobrariam uma taxa por transação (ou seja, crédito ou débito).

Crie uma hierarquia de herança que contenha a classe- -base Conta e as classes derivadas ContaPoupança e ContaCorrente, que herdem da classe Conta. A classe-base Conta deverá incluir um dado-membro do tipo double para representar o saldo da conta. A classe

deverá fornecer um construtor que receba um saldo inicial e o utilize para inicializar o dado-membro. O construtor deverá validar o saldo inicial para garantir que ele seja maior ou igual a 0.0. Se não for, o saldo deverá ser definido como 0.0, e o construtor deverá exibir uma

mensagem de erro que indique que o saldo inicial é inválido. A classe deverá fornecer três funções-membro. A função-membro creditar deverá somar um valor ao saldo atual. A função-membro debitar deverá retirar dinheiro da Conta e garantir que o valor do débito não

Programação orientada a objetos: herança 657 ultrapasse o saldo da Conta. Se isso acontecer, o saldo deverá ficar inalterado e a função deverá imprimir a mensagem “Valor do débito superior ao saldo da conta”. A função-membro retSaldo deverá retornar o saldo atual.

A classe derivada ContaPoupança deverá herdar a funcionalidade de uma Conta, mas também deverá incluir um dado-membro do tipo double que indique a taxa de juros (porcentagem) atribuída à Conta. O construtor da ContaPoupança deverá receber o saldo inicial, bem

como um valor inicial para a taxa de juros da Conta- Poupança. A ContaPoupança deverá fornecer uma função-membro public calculaJuros, que retorne um double indicando o valor dos juros recebidos por uma conta. A função-membro calculaJuros deverá determinar esse valor multiplicando a taxa de juros pelo saldo da conta. [Nota: ContaPoupança deverá herdar as funções-membro creditar e debitar como se encontra, sem redefini-las.] A classe derivada ContaCorrente deverá herdar da classe-base Conta e incluir um dado-membro adicional

do tipo double, que represente uma taxa cobrada por transação. O construtor de ContaCorrente deverá receber o saldo inicial, bem como um parâmetro indicando

um valor de taxa. A classe ContaCorrente deverá redefinir as funções-membro creditar e debitar, de modo que elas subtraiam a taxa do saldo da conta sempre que alguma transação for realizada com sucesso. As versões de ContaCorrente dessas funções deverão

chamar a versão Conta da classe-base para realizar as atualizações no saldo de uma conta. A função debit deContaCorrente deverá cobrar uma taxa somente se o dinheiro for realmente retirado (ou seja, se o valor de débito não ultrapassar o saldo da conta). [Dica: defina

a função debitar de Conta de modo que ela retorne um booleano que mostre se o dinheiro foi retirado. A seguir, use o valor de retorno para determinar se uma taxa deverá ser cobrada.]

Depois de definir as classes nessa hierarquia, escreva um programa que crie objetos de cada classe e teste suas funções-membro. Some juros ao objeto ContaPoupança, chamando sua função calculaJuros em primeiro lugar, e, depois, passando o valor de juros retornado à função creditar do objeto.

Passo 1

Vamos criar uma hierarquia de contas bancárias. A classe Account será a classe base das classes SavingsAccount e CheckingAccount.

A classe base armazenará o saldo da conta, bem como funções para operar com o saldo da conta. A classe SavingsAccount adicionará uma propriedade de taxa de juros à classe base, enquanto a CheckingAccount adiciona uma propriedade "taxa por transação" e substitui as funções setter da classe base para implementar a propriedade.

Classe da conta

Vamos declarar a classe base no arquivo de cabeçalho "Account.h" da seguinte forma:

#ifndef H_ACCOUNT_H

#define H_ACCOUNT_H

class Account {

public:

explicit Account(double balance);

void credit(double amount);

void debit(double amount);

double getBalance() const;

private:

double balance;

};

#endif

Agora, vamos implementar as funções no arquivo fonte "Account.cpp".

Primeiramente, o cabeçalho do arquivo junto com a implementação do construtor, que valida o valor passado:

#include

#include "Account.h"

using namespace std;

Account::Account(double balance) {

if (balance

{

Account::balance = 0;

cout

}

else

Account::balance = balance;

}

...

Passo 2

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

void Account::credit(double amount) {

balance += amount;

}

void Account::debit(double amount) {

if (amount > balance)

{

cout

}

else

{

balance -= amount;

}

}

double Account::getBalance() const {

return balance;

}

Classe Conta Poupança

A declaração da classe (a classe herda publicamente da classe Account):

#ifndef H_SAVINGSACCOUNT_H

#define H_SAVINGSACCOUNT_H

#include "Account.h"

class SavingsAccount : public Account {

public:

SavingsAccount(double balance, double interestRate);

double calculateInterest() const;

private:

double interestRate;

};

#endif

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

#include "SavingsAccount.h"

SavingsAccount::SavingsAccount(double balance,

double interestRate)

: Account(balance), interestRate(interestRate) {}

double SavingsAccount::calculateInterest() const {

return interestRate * Account::getBalance();

}

Passo 3

Classe Conta Corrente

Declaração de classe (para substituir funções, use o mesmo nome de função, bem como os tipos de parâmetro):

#ifndef H_CHECKINGACCOUNT_H

#define H_CHECKINGACCOUNT_H

#include "Account.h"

class CheckingAccount : public Account {

public:

CheckingAccount(double balance,

double feePerTransaction);

void credit(double amount);

void debit(double amount);

private:

double feePerTransaction;

};

#endif

Antes de podermos implementar a função debit(), teremos que modificar a definição da função Account::debit() para que ela retorne um valor booleano indicando se a transação passou com sucesso (certifique-se de editar a declaração da função no arquivo de cabeçalho também):

bool Account::debit(double amount) {

if (amount > balance)

{

cout

return false;

}

else

{

balance -= amount;

return true;

}

}

Agora, a implementação da classe CheckingAccount:

#include "CheckingAccount.h"

CheckingAccount::CheckingAccount(double balance,

double feePerTransaction)

: Account(balance),

feePerTransaction(feePerTransaction) {}

void CheckingAccount::credit(double amount) {

Account::credit(amount - feePerTransaction);

}

void CheckingAccount::debit(double amount) {

if (Account::debit(amount))

Account::debit(feePerTransaction);

}

O arquivo principal para fins de demonstração:

#include

#include "SavingsAccount.h"

#include "CheckingAccount.h"

using namespace std;

int main()

{

Account account(130);

account.credit(13);

account.debit(144);

cout

SavingsAccount savingsAccount(100, 0.01);

savingsAccount

.credit(savingsAccount.calculateInterest());

cout

CheckingAccount checkingAccount(100, 0.5);

checkingAccount.credit(10);

checkingAccount.debit(10);

cout

}

Resposta

Ver desenvolvimento