Clarification regarding copies of customers (objects) - c++

Question

In this code, I have created a vector of accounts in class bank, and (by my understanding) whenever I am adding an account, the bank class will create a different account object and push it into vectors, and when account constructor will initialize, it will make a different copy of customers every time a new account will be made through account vector in bank class - Please tell me if my understanding of this thing is clear? Here I am serially assigning account number.
`
class customer
{
string customerName;
string customerAddress;
int phoneNumber;
public:
customer(string customerName, string customerAddress, int phoneNumber)
{
this->customerName=customerName;
this->customerAddress=customerAddress;
this->phoneNumber=phoneNumber;
}
};
class account
{
customer customerObject;
int accountNumber;
static int accountBalance;
public:
account(int accountNumber, int accountBalance)
{
customer customerObject(customerName, customerAddress, phoneNumber);
this->accountNumber=accountNumber;
this->accountNumber=accountNumber;
}
int getBalance()
{
return accountBalance;
}
};
int account::accountBalance=0;
class bank
{
vector<account> accountContainer;
static int accountNumber;
int accountBalance=0;
public:
void addAccount(int deposit, string customerName, string customerAddress, int phoneNumber)
{
account accountObject(++this->accountNumber, this->accountBalance+deposit, customerName, customerAddress, phoneNumber);
accountContainer.push_back(accountObject);
}
void getBalance(int accountNumber)
{
if(accountNumber<=this->accountNumber)
{
return accountContainer[accountNumber-1].getBalance;
}
}
}
};
int bank::accountNumber=0;
int bank::accountBalance=0;
`

Answer 1

You are mostly correct. Only a single new customer object will be created each time you create a new account.
#include <string>
#include <vector>
#include <iostream>
#include <memory>
using namespace std;
class customer
{
string m_customerName;
string m_customerAddress;
int m_phoneNumber;
public:
customer(const std::string& customerName, const string& customerAddress, int phoneNumber)
{
m_customerName=customerName;
m_customerAddress=customerAddress;
m_phoneNumber=phoneNumber;
}
};
class account
{
customer m_customerObject;
int m_accountNumber;
int m_accountBalance;
public:
account(int accountNumber, int accountBalance, const std::string& customerName, const string& customerAddress, int phoneNumber):
m_customerObject(customerName, customerAddress, phoneNumber)
{
m_accountNumber=accountNumber;
m_accountBalance=accountBalance;
}
int getBalance()
{
return m_accountBalance;
}
};
class bank
{
vector<account> accountContainer;
public:
bank()
{
}
void addAccount(int accountNumber, int accountBalance, int deposit, const string& customerName, const string& customerAddress, int phoneNumber)
{
account accountObject(accountNumber, accountBalance+=deposit, customerName, customerAddress, phoneNumber);
accountContainer.push_back(accountObject);
}
int getBalance(int accountNumber)
{
try{
int balance = accountContainer.at(accountNumber).getBalance();
}
catch(std::exception& ex)
{
std::cout<<"Exception: "<<ex.what()<<std::endl;
}
}
};
int main()
{
bank b;
b.addAccount(1, 100, 2000,"John","222 Foo Street", 2222);
b.addAccount(2, 3000, 2000,"Roger","101 Apple Lane", 1111);
std::cout<<b.getBalance(0)<< std::endl;
std::cout<<b.getBalance(1);
return 0;
}

Answer 2

accountContainer.push_back(accountObject);
will copy accountObject into the accountContainer vector. So you have two instances of the account class. When addAccount returns, accountContainer goes out of scope and it is destroyed but the instance in the vector still exists.
See
http://www.cplusplus.com/reference/vector/vector/push_back/
it says this for push_back
Add element at the end
Adds a new element at the end of the vector, after its current last element. The content of val is copied (or moved) to the new element.
The compiler is however allowed to do all kinds of optimization as long as the end result is correct. Therefore it can be difficult to say exactly which functions (aka constructors/destructors) will be called during execution of the function. It may depend on optimization level. But the end result will always be correct. In this case the end result is that the vector holds an instance of the accountclass.
Since your accountclass contains a customer member each instance of account will of cause have its own customer instance.
Your constructor for account seems wrong as you make a local customer variable inside the constructor. Instead you shall just initialize the member variable. It could look like:
account(int account_number, int account_balance) :
customerObject(customerName, customerAddress, phoneNumber)
{
this->accountNumber=account_number;
this->accountBalance=account_balance;
}
or even:
account(int account_number, int account_balance) :
customerObject(customerName, customerAddress, phoneNumber),
accountNumber(account_number),
accounBalance(account_balance)
{}