BANGALORE INSTITUTE OF TECHNOLOGY
K. R. Road, V. V. Pura, Bengaluru – 560004
2023-2024
DEPARTMENT OF ELECTRICAL AND ELECTRONICS ENGINEERING
ASSIGNMENT PROJECT
on
“Define a class called Bank with all data members like customer name, address,
phone no., nominee, account nos., no. of accounts and their types, balance
amount in each of them. Define constructors, display functions and other member
functions to perform operations like updating customer data, debit and credit
transactions, search for a record given customer name/account no./phone no.”
Submitted in the partial fulfillment for the award of the degree of
BACHELOR OF ENGINEERING
in
ELECTRICAL AND ELECTRONICS ENGINEERING
Under the Guidance of
Dr .G .Sudha
Associate Professor and Head
Dept. of Electrical and Electronics Engineering
Submitted by
ADITYA PATEL 1BI23EE001
ANTAREEP SHARMA 1BI23EE006
KAILASH S 1BI23EE024
RISHI DRABLA 1BI23EE045
//PROBLEM STATEMENT
Define a class called Bank with all data members
like customer name, address, phone no., nominee,
account nos., no. of accounts and their types,
balance amount in each of them. Define
constructors, display functions and other member
functions to perform operations like updating
customer data, debit and credit transactions, search
for a record given customer name/account
no./phone no.
//SOURCE CODE
#include <iostream>
#include <vector>
#include <string>
#include <iomanip>
class Account {
public:
int accountNo;
std::string accountType;
double balance;
Account(int accNo, const std::string& accType, double bal)
: accountNo(accNo), accountType(accType), balance(bal) {}
};
class Bank {
private:
std::string customerName;
std::string address;
std::string phoneNo;
std::string nominee;
std::vector<Account> accounts;
public:
// Constructor
Bank(const std::string& name, const std::string& addr, const std::string& phone, const
std::string& nom)
: customerName(name), address(addr), phoneNo(phone), nominee(nom) {}
// Function to display customer data
void displayCustomerData() const {
std::cout << "---------------------------------\n";
std::cout << "Customer Information\n";
std::cout << "---------------------------------\n";
std::cout << "Customer Name : " << customerName << "\n";
std::cout << "Address : " << address << "\n";
std::cout << "Phone No. : " << phoneNo << "\n";
std::cout << "Nominee : " << nominee << "\n";
std::cout << "---------------------------------\n";
std::cout << "Accounts:\n";
for (const auto& acc : accounts) {
std::cout << "Account No. : " << acc.accountNo
<< ", Type : " << acc.accountType
<< ", Balance : $" << std::fixed << std::setprecision(2) << acc.balance <<
"\n";
}
std::cout << "---------------------------------\n";
}
// Function to update customer data
void updateCustomerData(const std::string& name, const std::string& addr, const
std::string& phone, const std::string& nom) {
customerName = name;
address = addr;
phoneNo = phone;
nominee = nom;
}
// Function to add an account
void addAccount(int accNo, const std::string& accType, double balance) {
accounts.push_back(Account(accNo, accType, balance));
}
// Function to debit amount
void debit(int accNo, double amount) {
for (auto& acc : accounts) {
if (acc.accountNo == accNo) {
if (acc.balance >= amount) {
acc.balance -= amount;
std::cout << "Debited $" << amount << " from account " << accNo << ".
New balance: $" << acc.balance << "\n";
} else {
std::cout << "Insufficient balance in account " << accNo << ".\n";
}
return;
}
}
std::cout << "Account " << accNo << " not found.\n";
}
// Function to credit amount
void credit(int accNo, double amount) {
for (auto& acc : accounts) {
if (acc.accountNo == accNo) {
acc.balance += amount;
std::cout << "Credited $" << amount << " to account " << accNo << ". New
balance: $" << acc.balance << "\n";
return;
}
}
std::cout << "Account " << accNo << " not found.\n";
}
// Function to search by customer name
bool searchByCustomerName(const std::string& name) const {
return customerName == name;
}
// Function to search by account number
bool searchByAccountNo(int accNo) const {
for (const auto& acc : accounts) {
if (acc.accountNo == accNo) {
return true;
}
}
return false;
}
// Function to search by phone number
bool searchByPhoneNo(const std::string& phone) const {
return phoneNo == phone;
}
};
void updateCustomerData(Bank& customer) {
std::string name, address, phone, nominee;
std::cout << "Enter new customer name: ";
std::getline(std::cin, name);
std::cout << "Enter new address: ";
std::getline(std::cin, address);
std::cout << "Enter new phone number: ";
std::getline(std::cin, phone);
std::cout << "Enter new nominee: ";
std::getline(std::cin, nominee);
customer.updateCustomerData(name, address, phone, nominee);
std::cout << "Customer data updated successfully.\n";
}
void performTransactions(Bank& customer) {
int choice, accNo;
double amount;
while (true) {
std::cout << "Select transaction type: 1. Debit 2. Credit 3. Exit: ";
std::cin >> choice;
if (choice == 3) break;
std::cout << "Enter account number: ";
std::cin >> accNo;
if (choice == 1) {
std::cout << "Enter amount to debit: ";
std::cin >> amount;
customer.debit(accNo, amount);
} else if (choice == 2) {
std::cout << "Enter amount to credit: ";
std::cin >> amount;
customer.credit(accNo, amount);
} else {
std::cout << "Invalid choice.\n";
}
}
}
int main() {
// Creating a Bank object
Bank customer("John Doe", "123 Elm Street", "555-1234", "Jane Doe");
// Adding accounts
customer.addAccount(1001, "Savings", 1500.00);
customer.addAccount(1002, "Checking", 2500.00);
// Display customer data
customer.displayCustomerData();
// Update customer data
updateCustomerData(customer);
// Perform some transactions
performTransactions(customer);
// Display customer data again
customer.displayCustomerData();
// Search for a record
std::string searchName, searchPhone;
int searchAccNo;
std::cout << "Enter customer name to search: ";
std::cin.ignore(); // To ignore the newline character left by previous input
std::getline(std::cin, searchName);
std::cout << "Searching for customer with name '" << searchName << "': " <<
(customer.searchByCustomerName(searchName) ? "Found" : "Not Found") << "\n";
std::cout << "Enter account number to search: ";
std::cin >> searchAccNo;
std::cout << "Searching for account number " << searchAccNo << ": " <<
(customer.searchByAccountNo(searchAccNo) ? "Found" : "Not Found") << "\n";
std::cout << "Enter phone number to search: ";
std::cin.ignore(); // To ignore the newline character left by previous input
std::getline(std::cin, searchPhone);
std::cout << "Searching for phone number '" << searchPhone << "': " <<
(customer.searchByPhoneNo(searchPhone) ? "Found" : "Not Found") << "\n";
return 0;
}
//OUTPUT
Customer Information
---------------------------------
Customer Name : John Doe
Address : 123 Elm Street
Phone No. : 555-1234
Nominee : Jane Doe
---------------------------------
Accounts:
Account No. : 1001, Type : Savings, Balance : $1500.00
Account No. : 1002, Type : Checking, Balance : $2500.00
---------------------------------
Enter new customer name: kailash
Enter new address: bangalore
Enter new phone number: 100
Enter new nominee: rishi
Customer data updated successfully.
Select transaction type: 1. Debit 2. Credit 3. Exit: 3
---------------------------------
Customer Information
---------------------------------
Customer Name : kailash
Address : bangalore
Phone No. : 100
Nominee : rishi
---------------------------------
Accounts:
Account No. : 1001, Type : Savings, Balance : $1500.00
Account No. : 1002, Type : Checking, Balance : $2500.00
---------------------------------
Program overview
The program simulates a basic banking system where customers can be added
with their personal details and multiple accounts Each account can perform
transactions like credit (deposit) and debit (withdrawal) Customers and their
account details can be displayed, and searches can be performed based on
customer name, phone number, or account number
Program Components
1 Data Structures:
Bank Structure: Represents the collection of customers (`Customer` structures)
Customer Structure: Holds details such as name, address, phone number, date
of birth, email, identification type, number of accounts, and an array of `Account`
structures
Account Structure: Contains attributes like account number, account type
(enum), balance, and interest rate
2 Functionality:
Initialization (`initializeBank`): Initializes the `Bank` structure with zero
customers
Adding Customers (`addCustomer`): Allows adding a new customer with their
details including optional attributes like date of birth, email, and identification
details
Displaying Customers (`displayCustomer`): Outputs details of a specific
customer including all associated accounts
Updating Customer Information (`updateCustomerAddress`,
`updateCustomerPhone`): Allows modifying customer address and phone number
Adding Accounts (`addAccount`): Enables adding new accounts to a customer
with initial balance and interest rate (if applicable)
Displaying Account Information (`displayAccount`): Shows account details
including account number, type, balance, and interest rate
Transaction Operations (`credit`, `debit`): Allows crediting (depositing) or
debiting (withdrawing) money from an account
Searching Customers (`searchCustomerByName`, `searchCustomerByPhone`,
`searchCustomerByAccountNumber`): Facilitates finding customers based on their
name, phone number, or account number
3 Example Usage:
The `main` function demonstrates usage scenarios by adding customers, adding
accounts, performing transactions, and displaying customer and account details
Detailed Analysis
Pros:
Modular Design: The program is structured into functions for specific tasks (eg,
adding customers, handling accounts), promoting code reusability and
maintainability
Data Encapsulation: Customer and account details are encapsulated within
structures, facilitating organized data management and reducing complexity
Functionality: Provides essential banking operations such as account creation,
transaction handling, and customer information management
Search Functionality: Allows efficient retrieval of customer information based on
various criteria, enhancing user experience
Cons:
Limited Error Handling: The program lacks comprehensive error handling
mechanisms (eg, input validation, handling insufficient balance), which could lead
to unexpected behavior in certain scenarios
Static Data Storage: Uses static arrays for customers and accounts
(`MAX_CUSTOMERS` and `MAX_ACCOUNTS`), which may limit scalability for larger
systems
Simplistic Account Management: Accounts have basic attributes like balance and
interest rate, lacking more complex features like transaction history or account
status tracking
Minimal Security Measures: The program does not address security concerns such
as user authentication or secure data handling, which are crucial in realworld
banking applications
Potential Improvements:
Dynamic Memory Allocation: Replace static arrays with dynamic
memory allocation to handle a variable number of customers and
accounts more efficiently
Error Handling: Implement robust error handling and validation
mechanisms to handle edge cases and ensure data integrity
Enhanced Account Features: Introduce additional account features such as transaction history, overdraft
protection, or different types of fees
Security Enhancements: Incorporate security measures like encryption for sensitive data and user
authentication for accessing accounts
User Interface: Develop a userfriendly interface (eg, commandline menu or graphical interface) to
improve usability and interaction with the banking system
Conclusion
In summary, while the provided program offers basic functionality for
managing customers and accounts in a simulated banking environment,
there are several areas for enhancement to better align with realworld
banking systems By addressing these improvements, the program could
become more robust, secure, and scalable, offering a more
comprehensive solution for banking operations simulation
Adding Attributes:
1. Date of Birth (DOB)
Add a `dob` attribute to the `Customer` structure to store the date of birth.
Example: `char dob[11];` (assuming format "YYYY-MM-DD").
2. Email Address:
Include an `email` attribute in the `Customer` structure to store the customer's email address.
Example: `char email[50];`.
3. Identification Details:
Add attributes like `idType` (type of identification document) and `idNumber` (identification number).
Example: `char idType[20];` and `char idNumber[50];`.
4. Account Status:
Introduce a `status` attribute in the `Account` structure to indicate whether the account is active,
closed, or suspended.
Example: `int status;` (where 0 = active, 1 = closed, etc.).
Removing Attributes:
1. Nominee:
-If nominee details are not needed, remove the `nominee` attribute from the `Customer` structure.
Example: Delete `char nominee[50];`.
2. Multiple Accounts:
If customers are only allowed a single account, remove the array of `Account` structures from the
`Customer` structure (`accounts[MAX_ACCOUNTS]`).
Example: Adjust `Customer` structure to hold a single `Account` instead of an array.
Other Considerations:
1. Enhanced Account Information:
Extend the `Account` structure to include more details like interest rate, overdraft limit, or transaction
history.
Example: Add `float interestRate;` and `float overdraftLimit;`.
2. Security and Authentication:
Implement additional attributes or methods for security purposes, such as PIN numbers for account
access.
3. Transaction Types:
Introduce an enumeration or additional attributes in the `Account` structure to differentiate between
transaction types (e.g., deposit, withdrawal, transfer).
4. Data Validation:
Implement validation mechanisms for attributes like phone numbers, email addresses, and
identification numbers to ensure data integrity.
Additional Attributes: The `Customer` structure now includes `dob` (date of birth), `email`, `idType` (type
of identification), and `idNumber` (identification number).
Modified Functions: Functions like `addCustomer` and `displayCustomer` have been updated to handle
these additional attributes.
Account Enhancements: The `Account` structure now includes `interestRate` to represent the interest
rate for accounts that earn interest.
