findacct is a bad example of a function to be moved inside a class because doesn't do anything on a specific account and just searches among several accounts.
You can move this kind of function inside the BankAccount class as a static member function, but static member functions are really not that different from global functions with fancy names.
Much more interesting for the OOP approach would be moving some function that acts on a specific bank account inside the BankAccount class e.g. something like changing from
bool withdraw(int account_id, int amount)
to
bool BankAccount::withdraw(int amount)
In the following example code I've stored all accounts in a private vector. To create a new account you must call a static class function providing the ID number. Note that this code contains many subtleties and can be dangerous to use as a basis unless you understand it fully... this is unfortunately a characteristic of C++ where apparently logical statements may act logically or can just make your computer to act strangely. My suggestion is to grab a good C++ book and read it cover to cover before or while experimenting with the language.
C++ is just too complex and sometimes illogical (for historical reasons) to learn it just with experimentation.
#include <vector>
#include <algorithm>
#include <stdlib.h>
#include <stdio.h>
class BankAccount
{
private:
int id; // Unique identifier for this account
int balance; // How much money is present on this account
static std::vector<BankAccount*> accounts; // Global list of valid accounts
// Constructor - private!
BankAccount(int id) : id(id), balance(0)
{
// Add to global accounts list
accounts.push_back(this);
}
// Destructor - also private
~BankAccount()
{
// Remove from global accounts list
accounts.erase(std::find(accounts.begin(), accounts.end(),
this));
}
public:
// Public global function to create a new account
static bool createAccount(int id)
{
if (find(id) != NULL)
{
return false;
}
else
{
new BankAccount(id);
return true;
}
}
// This is a global function that given the unique identifiers
// returns a pointer to the account or NULL if non-existent
static BankAccount *find(int id)
{
for (int i=0,n=accounts.size(); i<n; i++)
if (accounts[i]->getId() == id)
return accounts[i];
return NULL;
}
// This is a global function that transfers money from one
// account to another and returns true if the operation is
// successful (i.e. if the source account has enough money)
static bool transfer(int from_id, int to_id, int amount)
{
BankAccount *from = find(from_id);
BankAccount *to = find(to_id);
if (from != NULL && // Is first account valid?
to != NULL && // Is second account valid?
from->withdraw(amount)) // Is there enough money?
{
to->deposit(amount); // move the withdrawn money
return true;
}
else
{
// Operation did not succeed
return false;
}
}
// Returns the id of the account
int getId()
{
return id;
}
// Returns the current balance for the account
int getBalance()
{
return balance;
}
// Deposit a sum on the bank account
void deposit(int amount)
{
balance += amount;
}
// Tries to withdraw the specified amount from the account
bool withdraw(int amount)
{
if (amount <= balance)
{
balance -= amount;
return true;
}
else
{
return false;
}
}
};
// This is also needed; the declaration of accounts inside
// the class (.h) doesn't actually allocate the vector... simply
// tells that the following line will be present in a .cpp
std::vector<BankAccount*> BankAccount::accounts;
///////////////////////////////////////////////////////////////////////////////////
// Do some test...
#define check(x) \
do { printf("check: %s\n", #x); if (!(x)) { \
printf("*** Fatal error (line %i)", __LINE__); \
exit(1); }}while(0)
int main(int argc, const char *argv[])
{
check(BankAccount::createAccount(6502) == true);
check(BankAccount::createAccount(386) == true);
// duplicate account!
check(BankAccount::createAccount(6502) == false);
// Not enough founds
check(BankAccount::transfer(386, 6502, 1000) == false);
// Deposit
BankAccount *p386 = BankAccount::find(386);
check(p386 != NULL);
p386->deposit(1000);
// Valid and invalid transfers...
check(BankAccount::transfer(386, 6502, 1000) == true); // ok
check(BankAccount::transfer(386, 6502, 1000) == false); // No more funds
check(BankAccount::transfer(6502, 386, 500) == true); // Give some back
check(BankAccount::transfer(386, 6502, 1000) == false); // Not enough funds
check(BankAccount::transfer(386, 6502, 400) == true); // ok
check(BankAccount::find(386)->getBalance() == 100);
check(BankAccount::find(6502)->getBalance() == 900);
return 0;
}
