Hello! (Spelled polymorphism wrong in title, I know... it's late!)
Now, I understand the concepts of both just fine, but implementing them is where I really run into trouble; this is especially when I'm given a specific problem to solve by using them (i.e. my current assignment).
Okay so here's an overview of my current assignment:
Create a C++ application to handle Savings and Checking accounts. Start with an Account class as the base class to the Savings and the Checking derived classes. The Account class need only contain the account number and account balance and any functions that may be applied directly to the Account class. The Savings account contains only the interest rate for the account and accumulated interest paid. The Checking account needs a Boolean variable to indicate if the account has overdraft protection and, if so, a member to store the overdrawn amount(s) as “loans.”
All accounts must have set and get functions for their data members (all data members must be private).
Account balance may never be negative.
All accounts must contain a print function.
The Account class must have virtual functions for all functions that may vary in the derived classes.
There must be at least one “pure” virtual function in the Account class.
In addition to deposit and withdrawal functions for each account, the following are needed:
For Savings: a function to change interest rate (min rate 3% - max rate 6.5%) and a function to calculate and update interest for the account.For Checking: a function to change the overdraft flag (T to F; F to T); a deposit function that processes any deposited amount against an existing overdraft loan before updating Account balance; a check payment function that handles potential overdrawn amounts instead of a withdrawal.
All functions should have an appropriate display in the test program to indicate what action is (has) taken place.
The test program should exercise all account constructors and methods.
It's a toughie, right? Maybe not for most of you, but for me it seems impossible.
Here's what I have so far, a lot of it is probably wrong (and I know it's not much):
-MAIN IS CURRENTLY EMPTY-
ACCOUNT.H
#include <string>
using namespace std;
#ifndef ACCOUNT_CLASS
#define ACCOUNT_CLASS
class Account
{
private:
string acctNum;
double acctBal;
public:
Account(string aN = "", double aB = 0.0);
virtual void accountUpdate() = 0;
virtual void deposit() = 0;
void setAcctNum(string aN);
void setAcctBal(double aB);
string getAcctNum() const;
double getAcctBal() const;
virtual void printData() const;
}
#endif
ACCOUNT.CPP
#include <string>
#include <iomanip>
#include <iostream>
using namespace std;
#include "Account.h"
Account :: Account(string aN, double aB)
{
acctNum = aN;
acctBal = aB;
}
virtual void Account :: printData() const;
{
cout << "\n" << "Current balance for acct. # "<< acctNum << ": $"
<< acctBal << endl;
}
//================================Set Mutator Function declarations=============================================
void Account :: setAcctNum(string aN)
{
acctNum = aN;
}
void Account :: setAcctBal(double aB)
{
acctBal = aB;
}
//================================Get Accessor Function declarations=============================================
string Account :: getAcctNum() const
{
return acctNum;
}
double Account :: getAcctBal() const
{
return acctBal;
}
CHECKING.H
#include <string>
#include "Account.h"
#ifndef CHECKING_CLASS
#define CHECKING_CLASS
using namespace std;
class Checking: public Account
{
private:
bool overDraft;
double loan;
public:
Checking(bool oD = false, double lN = 0.0);
double withdraw();
void setOverDraft(bool oD);
void setLoan(double lN);
bool getOverDraft() const;
double getLoan() const;
}
#endif
CHECKING.CPP
#include <string>
#include <iomanip>
#include <iostream>
using namespace std;
#include "Checking.h"
Checking :: Checking(bool oD, double lN)
{
overDraft = oD;
loan = lN;
}
void Checking :: printData() const;
{
cout << "\n" << "Current loan balance for acct. # "<< acctNum << ": $"
<< loan << endl;
}
//================================Set Mutator Function declarations=============================================
void Checking :: setOverDraft(bool oD)
{
overDraft = oD;
}
void Checking :: setLoan(double lN)
{
loan = lN;
}
//================================Get Accessor Function declarations=============================================
bool Checking :: getOverDraft() const
{
if (withdraw > acctBal)
{
loan = withdraw - acctBal;
return true
}
else
return false;
}
double Checking :: getLoan() const
{
return loan;
}
SAVINGS.H
#include <string>
#include "Account.h"
#ifndef SAVINGS_CLASS
#define SAVINGS_CLASS
using namespace std;
class Savings: public Account
{
private:
int interestRate;
double interestPaid;
public:
Savings(int iR = 0, double iP = 0.0);
double withdraw();
void setRate(int iR);
void setPaid(double iP);
int getRate() const;
double getPaid() const;
}
#endif
SAVINGS.CPP
#include <string>
#include <iomanip>
#include <iostream>
using namespace std;
#include "Savings.h"
Savings :: Savings(int iR, double iP)
{
interestRate = iR;
interestPaid = iP;
}
void Savings :: printData() const;
{
cout << "\n" << "Current interest rate for acct. # "<< acctNum << ": "
<< interestRate << "\n" << "Current interest paid for acct. # "<<
acctNum << ": " << interestPaid << endl;
}
//================================Set Mutator Function declarations=============================================
void Savings :: setRate(int iR)
{
interestRate = iR;
}
void Savings :: setPaid(double iP)
{
interestPaid = iP
}
//================================Get Accessor Function declarations=============================================
int Savings :: getRate() const
{
return interestRate;
}
double Savings :: getPaid() const
{
return interestPaid;
}
Okay, what I'm currently looking for is just some general comments on what I am doing totally wrong. Just some guidelines. I'm still trying to teach myself inheritance and learn how to implement it into my classes, so a lot of this is probably very wrong. Hopefully once I iron out the big issues, I can start understanding what is being done and get down to the "nitty gritty" of both inheritance and polymorphism.
Thank you! :)