Question

(Account Class) Create a class called account that a bank might use to represent customers' bank accounts. Your class should include one data member of type int to represent the account balance. [Note: In subsequent chapters, we'll use numbers that contain decimal points (e.g., 2.75)called floating- point valuesto represent dollar amounts.] Your class should provide a constructor that receives an initial balance and uses it to initialize the data member. The constructor should validate the initial balance to ensure that it is greater than or equal to \(0 .\) If not, the balance should be set to 0 and the constructor should display an error message, indicating that the initial balance was invalid. The class should provide three member functions. Member function credit should add an amount to the current balance. Member function debit should withdraw money from the Account and should ensure that the debit amount does not exceed the account's balance. If it does, the balance should be left unchanged and the function should print a message indicating "Debit amount exceeded account balance." Member function getBalance should return the current balance. Create a program that creates two Account objects and tests the member functions of class Account.

Short answer

Define the `Account` class with a constructor and methods as specified, handle invalid checks, then test using two accounts.

Step-by-step solution

Define the Account Class

We begin by defining the `Account` class. It will have an integer data member to represent the balance of the account. The class will have a constructor that initializes this balance and member functions for the operations specified.

Implement the Constructor

The constructor for the `Account` class should initialize the balance using a given argument. It should check that the initial balance is non-negative. If it is negative, initialize the balance to 0 and print an error message.

Implement the Credit Function

Create a `credit` function that takes an integer parameter and adds this amount to the account balance. This function does not need to perform validation beyond adding the credit amount.

Implement the Debit Function

Implement the `debit` function which tries to subtract a given amount from the balance. If the debit amount exceeds the current balance, print an error message and leave the balance unchanged.

Implement the Get Balance Function

Define the `getBalance` function that simply returns the current balance of the account. No additional logic is necessary for this function.

Test the Account Class

Create a program to test the methods of the `Account` class. Instantiate two `Account` objects with different initial balances. Test crediting and debiting each account and confirm the functions work as expected. Print the balance after each operation.

Key concepts

Account class

In object-oriented programming, an `Account` class is a blueprint that models a bank account system. It mainly encapsulates the concept of a customer’s bank account through data members and functions that manipulate the account’s state.
This class includes a data member, typically of type `int`, representing the account balance. By encapsulating this balance, the class can expose methods to interact with it, while controlling how it is changed.
An account class should ideally maintain the integrity of its data. For example, by ensuring a balance cannot be negative or directly manipulated outside of controlled methods. In C++, an `Account` class usually provides member functions that allow adding, withdrawing, and querying the balance. These functions ensure that any interaction with the balance adheres to defined rules, such as limits on withdrawals or setting up initial conditions.

Constructor function

A constructor is a special member function called automatically when an object of a class is created. The primary role of a constructor is to initialize the object’s data members. In the `Account` class, the constructor function serves to set up the account with an initial balance.
The constructor does more than just assign values; it also contains logic to ensure the values are valid. This class specifically initializes the balance only if the provided amount is greater than or equal to zero. Otherwise, it defaults the balance to zero and provides a clear error message indicating the initial balance was invalid.
Constructors in C++ are powerful as they help enforce constraints right when an object is created, ensuring the object starts its lifecycle in a valid state.

Data validation

Data validation is a crucial aspect of programming that involves checking and ensuring that the data being processed meets certain criteria. In the context of the `Account` class, data validation ensures that the account starts with a non-negative balance.
When a constructor receives an invalid initial balance, it doesn't just fail silently. Instead, it rejects the invalid data by setting the balance to zero and informs the user with an error message. This form of validation prevents inconsistent states in the system.
Validation is also applied in other methods like `debit`, which ensures that money cannot be withdrawn unless the account balance is sufficient. Such checks help maintain data integrity and prevent operations that would lead to errors or exceptions.

Member functions

Member functions are integral components of a class, providing the means to interact with an object's data members. The `Account` class employs several key member functions for interaction.

• `credit`: This function adds a specified amount to the account balance, allowing deposits. It assumes the amount is valid since it doesn't reduce the balance.
• `debit`: This function attempts to subtract an amount from the balance for withdrawals. It includes logic to ensure the balance doesn’t fall below zero, protecting the account from overdrawing. If the intended debit amount exceeds the balance, it prevents the operation and notifies the user with an error message.
• `getBalance`: A straightforward method that returns the current balance. It serves as a safe way to check the balance without altering it.

Member functions not only perform operations but help encapsulate the logic necessary to maintain consistent and valid states within an object, thereby following good programming practices.