Question

c++ help please.

Savings accounts: Suppose that the bank offers two types of savings accounts: one that has no minimum balance and a lower interest rate and another that requires a minimum balance but has a higher interest rate (the benefit here being larger growth in this type of account).

Checking accounts: Suppose that the bank offers three types of checking accounts: one with a monthly service charge, limited check writing, no minimum balance, and no interest; another with no monthly service charge, a minimum balance requirement, unlimited check writing and lower interest; and a third with no monthly service charge, a higher minimum balance requirement, a higher interest rate, and unlimited check writing.

Certificate of deposit (CD): In an account of this type, money is deposited and left for some time, and these accounts draw higher interest rates than savings or checking accounts. Suppose that you purchase a CD for six months. We then say that the CD will mature in six months (i.e. you can take the money back out). The penalty for early withdrawal is steep.

Note that the classes bankAccount and checkingAccount are abstract. That is, we cannot instantiate objects of these classes. The other classes in the above figure above are not abstract.

bankAccount: Every bank account has an account number, the name of the owner, and a balance. Therefore, instance variables such as name, accountNumber, and balance should be declared in the abstract class bankAccount. Some operations common to all types of accounts are retrieve account owners name, account number, and account balance; make deposits; withdraw money; and create monthly statements. So include functions to implement these operations. Note that some of these functions will be pure virtual. (Which ones?)

checkingAccount: A checking account is a bank account. Therefore, it inherits all the properties of a bank account. Because one of the objectives of a checking account is to be able to write checks, include the pure virtual function writeCheck to write a check.

serviceChargeChecking: A service charge checking account is a checking account. Therefore, it inherits all the properties of a checking account. For simplicity, assume that this type of account does not accrue any interest, has a monthly operating cost of $10/month, allows the account holder to write a limited number of checks each month (max 5 checks per month), charges the account holder $5 per check written over the max number of checks in a given month, and does not require any minimum balance. Include appropriately named constants, instance variables, and functions in this class.

noServiceChargeChecking: A checking account with no monthly service charge is a checking account. Therefore, it inherits all the properties of a checking account. Furthermore, this type of account accrues interest (2%), allows the account holder to write checks, and requires a minimum balance ($1000).

highInterestChecking: A checking account with high interest is a checking account with no monthly service charge. Therefore, it inherits all the properties of a no service charge checking account. Furthermore, this type of account pays higher interest (5%) and requires a higher minimum balance ($5000) than the no service charge checking account.

savingsAccount: A savings account is a bank account. Therefore, it inherits all the properties of a bank account. Furthermore, a savings account accrues interest at a 3% rate, compounded monthly.

highInterestSavings: A high-interest savings account is a savings account. Therefore, it inherits all the properties of a savings account. It has a minimum balance ($2500) but has a higher interest accrual rate of (5%).

The main:

#include <iostream>

#include <iomanip>

#include <cstdlib>

#include "bankAccount.h"

#include "savingsAccount.h"

#include "highInterestSavings.h"

#include "noServiceChargeChecking.h"

#include "serviceChargeChecking.h"

#include "highInterestChecking.h"

#include "certificateOfDeposit.h"

#include "checkingAccount.h"

using namespace std;

int main()

{

// array of bankAccount type pointers

// pointers so that you can store any of the inherited

// account types without a slicing (information loss) problem

bankAccount *accountsList[6];

  

// create six accounts, one of each type

accountsList[0] = new savingsAccount("Bill", 10200, 2500);

accountsList[1] = new highInterestSavings("Susan", 10210, 2000);

accountsList[2] = new noServiceChargeChecking("John", 20100,

3500);

accountsList[3] = new serviceChargeChecking("Ravi", 30100, 1800);

accountsList[4] = new highInterestChecking("Sheila", 20200,

   6000);

accountsList[5] = new certificateOfDeposit("Hamid", 51001, 18000,

   0.075, 18);

  

// calculate and print january statements

cout << "January:\n-------------" << endl;

for (int i = 0; i < 6; i++)

{

accountsList[i]->createMonthlyStatement();

accountsList[i]->print();

cout << endl;

}

  

// calculate and print january statements

cout << "\nFebruary:\n-------------" << endl;

for (int i = 0; i < 6; i++)

{

accountsList[i]->createMonthlyStatement();

accountsList[i]->print();

cout << endl;

}

  

//

for (int i = 0; i < 6; i++)

{

accountsList[i]->withdraw(500);

}

  

// calculate and print january statements

cout << "\nMarch:\n-------------" << endl;

for (int i = 0; i < 6; i++)

{

accountsList[i]->createMonthlyStatement();

accountsList[i]->print();

cout << endl;

}

  

system("pause");

return 0;

}

For any account type that requires a minimum balance, withdrawal amounts that would bring the account below the minimum balance should be strictly prohibited. Develop a short protected member function that would check this.

Answer 1

let minimum balance must be 500 so the function is like

withdraw(int n)

{

minimum=500;

if(n<=minimum)

{

printf("Amount couldn't be withdraw");

}

else

{

savingsamount=savingsamount-n;

printf("successfully withhdrawl the amount");

}

}