Question

Create a savingsAccount class. Use a static data member annualinterestRate to store the annual interest rate for each of the savers. Each member of the class contains a private data member savingsBatance indicating the amount the saver currently has on deposit. Provide member function calculateMonthlyInterest that calculates the monthly interest by multiplying the balance by annualinterestRate divided by \(12 ;\) this interest should be added to savingsBalance. Provide a static member function modifyInterestrate that sets the static annualtnterestrate to a new value. Write a driver program to test class SavingsAccount. Instantiate two different objects of class SavingsAccount, saver1 and saver2, with balances of \(\$ 2000.00\) and \(\$ 3000.00,\) respectively. Set the annualtnterestRate to 3 percent. Then calculate the monthly interest and print the new balances for each of the savers. Then set the annualtnterestRate to 4 percent, calculate the next month's interest and print the new balances for each of the savers.

Short answer

Balances after first interest calculation: $2005 (Saver1), $3007.50 (Saver2). After new interest rate: $2011.68 (Saver1), $3017.52 (Saver2).

Step-by-step solution

Define Class Structure

Create a `SavingsAccount` class with two primary data members: `annualInterestRate` (a static float) and `savingsBalance` (a private float for each instance). Also, define the methods `calculateMonthlyInterest` and `modifyInterestRate`.

Implement Static and Member Methods

Define `calculateMonthlyInterest` method to update `savingsBalance` by adding \( \text{annualInterestRate} / 12 \times \text{savingsBalance} \). Define `modifyInterestRate` as a static method to update `annualInterestRate`.

Instantiate Saver Objects

Instantiate two `SavingsAccount` objects: `saver1` with `savingsBalance = 2000.00` and `saver2` with `savingsBalance = 3000.00`. Set the `annualInterestRate` to 0.03.

Calculate First Month Interest

Use `calculateMonthlyInterest` for both `saver1` and `saver2` to compute and add the monthly interest. Print the updated balances. For `saver1`: \[ \text{Interest} = \frac{0.03}{12} \times 2000 = 5 \] Updated balance: \(2005.00. For `saver2`: \[ \text{Interest} = \frac{0.03}{12} \times 3000 = 7.5 \] Updated balance: \)3007.50.

Modify Interest Rate and Recalculate

Invoke `modifyInterestRate` to change `annualInterestRate` to 0.04. Recalculate monthly interest for both savers using `calculateMonthlyInterest`. Print the updated balances. For `saver1`: \[ \text{Interest} = \frac{0.04}{12} \times 2005 = 6.6833 \] Updated balance: \(2011.6833. For `saver2`: \[ \text{Interest} = \frac{0.04}{12} \times 3007.5 = 10.025 \] Updated balance: \)3017.525.

Key concepts

Static Data Members

In C++ programming, a *static data member* is a class variable shared among all instances of the class. For our `SavingsAccount` example, the `annualInterestRate` is a static data member. This means all objects of the `SavingsAccount` class, like saver1 and saver2, share the same interest rate.
This approach offers several advantages:

• Memory Efficiency: Static data members are allocated only once, which saves memory.
• Consistent Behavior: When one object's method changes the static data member, all other objects see this update. Thus, changing the `annualInterestRate` alters it for all savers.

To define a static data member in a class, you use the `static` keyword. Modifying it can be done via a static member function, which we'll discuss further below.

Member Functions

*Member functions* in a C++ class operate on the data members and define the behavior of the class. For the `SavingsAccount` class, we have two critical member functions: `calculateMonthlyInterest` and `modifyInterestRate`.
The `calculateMonthlyInterest` function adds the monthly interest to the `savingsBalance`. It does this by using the formula:
\[ \text{monthly interest} = \frac{\text{annualInterestRate}}{12} \times \text{savingsBalance} \]
When called, this function updates the current balance of the specific saver instance.

• Purpose: This method shows how a class can encapsulate operations on its data.
• Practical Use: Automates the interest calculation over time without external input for each saver.

The `modifyInterestRate` function, being static, helps in changing the shared `annualInterestRate` for all instances. Such static functions are convenient when a method needs to work at the class level, rather than affecting any single object directly.

Interest Calculation

Calculating interest is a common task in financial applications, and understanding how this works in code is essential. In our `SavingsAccount` class, interest calculation is performed monthly.
Here's a step-by-step breakdown:

• Access Current Balance: Use the instance's current `savingsBalance` value.
• Apply Interest Formula: Multiply `savingsBalance` by the rate (as a fraction of a year) given by \( \frac{\text{annualInterestRate}}{12} \).
• Add to Balance: The result is added to `savingsBalance`, reflecting accrued interest.

This process shows the power of connecting logic and data within a class. It ensures that each time you invoke the interest calculation, the latest rate and balance are used seamlessly. Changing the `annualInterestRate` via `modifyInterestRate` means that future calculations will incorporate the updated value, affecting all current and future savers identically.

Driver Program

A *driver program* serves as the entry point for testing and running classes like `SavingsAccount`. In your program, instantiate two saver objects, `saver1` and `saver2`, with initial balances of 2000.00 and 3000.00, respectively.
Here's a summary of the driver program tasks:

• Instantiate Objects: Create `saver1` and `saver2` with their respective balances.
• Set Initial Interest Rate: Use `modifyInterestRate` to set a shared `annualInterestRate`, initially to 3%.
• Calculate and Display Interest: Call `calculateMonthlyInterest` on both savers, then print the updated balances.
• Update and Recalculate: Change the `annualInterestRate` to 4% and repeat the interest calculation to see the effect.

Driver programs are crucial in object-oriented programming. They provide a real-world testing ground for the behavior of your classes and ensure logical correctness across different scenarios.