[SOLVED] CENG242 Program3-Bank-System-Simulation

In this homework you are a programmer and your supervisors want certain features in their Bank system. Your task is to implement Transaction, Account and Bank systems that are provided you with a header file(You will not edit header files). As situation requested shiny features of the latest C++ is not available to you. Therefore, you have to be careful with your programs memory management.

1             Class Definitions

1.1           Transaction

Transaction is the most basic class in this homework. Basically, it holds a certain amount and date of the Transaction.

class Transaction { private :

double _amount;

time_t _date;

public :

/∗∗

∗ Empty constructor ∗ give −1 to everything

∗/ Transaction() ;

/∗∗

∗ Constructor

∗

∗ @param amount The value                     of                  Transaction (Can be ∗ @param date Transaction date ∗/ Transaction( double amount, time_t date) ; /∗∗ ∗ Copy Constructor . ∗ ∗ @param rhs The Transaction to be copied . ∗/ Transaction( const Transaction& rhs) ; /∗∗ ∗ Compare two Transaction based on their                                    date ∗ ∗ @param rhs Compared Transaction	negative		or	positive )
∗ @return           If               current  Transaction happened before return         true ∗ else              return       false ∗/ bool operator <(const Transaction& rhs) const ; /∗∗ ∗ Compare two Transaction based on their                                    date ∗ ∗ @param date Compared date	the	given		Transaction ←–
∗ @return             If       current                            Transaction happened after true ∗ else              return       false	the	given Transaction                   return←–

∗/ bool operator >(const Transaction& rhs) const ;

/∗∗

∗ Compare a Transaction with a given date

∗

∗ @param date Compared date

∗ @return       If       current              Transaction happened before      the given date return         true

∗ else        return        false

∗/ bool operator <(const time_t date) const ;

/∗∗

∗ Compare a Transaction with a given date

∗

∗ @param date Compared date

∗ @return       If       current               Transaction happened after      the given date return         true

∗ else        return        false

∗/ bool operator >(const time_t date) const ;

/∗∗

∗ Sum the value                  of two Transaction amounts

∗

∗ @param rhs The transaction                 to sum over

∗ @return The output of                      the summation in double format

∗/ double operator+(const Transaction& rhs) ;

/∗∗

∗ Sum the value                       of a Transaction with another double

∗

∗ @param add The amount to sum over

∗ @return The output of                      the summation in double format

∗/ double operator+(const double add) ;

/∗∗

∗ Assignment operator

∗

∗ @param rhs Transaction to assign ∗ @return this Transaction

∗/

Transaction& operator=(const Transaction& rhs) ;

/∗∗

∗ Stream overload

∗

∗ What to stream :

∗ Transaction amount”tab−tab”hour : minute : second−day/month/year ( in                                                                                                     localtime )

∗

∗ @param os Stream to be used .

∗ @param transaction                    Transaction to be streamed .

∗ @return the current Stream

∗/ friend std : : ostream& operator <<(std : : ostream& os, const Transaction& ←transaction) ;

};

1.2           Account

The account is defined for a single user and users have their respective ids. Accounts also hold Transaction information of their user in a sorted manner.

class Account { private :

int _id;

Transaction∗∗ _activity; int∗ _monthly_activity_frequency;

public :

/∗∗

∗ Empty constructor

∗ give the id as −1 ∗ give nullptr for pointers

∗/ Account() ;

/∗∗

Constructor

∗ Note : The given             activity         array       will                           have 12 Transaction∗

∗ Each of         these            Transaction∗ will    represent a month from the 2019

∗ Basicaly            activity [0] will     represent January activity [11]              will     represent February activity [11]              will     represent March

. . .

activity [10]             will          represent November activity [11]        will   represent December

∗ activity [0]                    will          only contain                   Transactions happened in January ∗ However , be careful that Transactions inside of activity [ i ] will not be in←sorted order ∗ For Example : We are                      certain        that          activity [0]         is        containing            Transactions ←–
happened in January 2019 ∗ But we are not sure which of them happened                                        f i r s t .
∗ I     strongly     suggest you to use a sorting             algorithm               while Transaction to your object .	storing            these ←–
∗ ( Sorting by the date , So that you can                                            directly              use them ) ∗ (You can use bubble                        sort ) ∗ ∗ @param id            id     of         this Account	in stream overload←–
∗ @param activity 2d Transaction array f i r s t layers lenght month	is           12 for        each ←–
∗ @param monthly activity frequency how many transactions ∗/	made in each month

Account( int id, Transaction∗∗ const activity,                                    int ∗ monthly_activity_frequency←–

) ;

/∗∗

∗ Destructor

∗

∗ Do not    forget     to              free          the space you have created ( This assignment does not ←use smart pointers )

∗/

˜Account() ;

/∗∗

∗ Copy constructor (Deep copy)

∗

∗ @param other The Account to be copied

∗/

Account( const Account& rhs) ;

/∗∗

∗ Copy constructor (Deep copy)

∗

∗ This copy constructors                   takes two time t           elements

∗ Transactions of the old Account will be copied to new Account ∗ i f and only i f they are between these given dates ∗ Given dates will not be included .

∗

∗ @param rhs The Account to be copied

∗ @param start date Starting date for transaction to be copied . ∗ @param end date Ending date for transactions to be copied .

∗/

Account( const Account& rhs, time_t start_date, time_t end_date) ;
/∗∗ ∗ Move constructor ∗
∗ @param rhs Account which you ∗/ Account(Account&& rhs) ; /∗∗ ∗ Move assignment operator ∗	will	move the	resources	from
∗ @param rhs Account which you ∗ @return             this       account	will	move the	resources	from

∗/

Account& operator=(Account&& rhs) ;

/∗∗

∗ Assignment operator ∗ deep copy

∗

∗ @param rhs Account to assign ∗ @return this account

∗/ Account& operator=(const Account& rhs) ;

/∗∗

∗ Equality comparison overload

∗

∗ This operator               checks only id          of        the Account

∗

∗ @param rhs The Account to compare

∗ @return returns           true      i f       both ids            are same false                              othervise

∗/ bool      operator==(const Account& rhs) const ; /∗∗

∗ Equality comparison overload

∗

∗ This operator               checks only id          of        the Account

∗

∗ @param id to compare

∗ @return returns           true      i f       both ids            are same false                              othervise

∗/ bool operator==(int id) const ;

/∗∗

∗ sum and equal                   operator ∗ Add Transactions                        of two Accounts
∗ You have to add transactions                                in       correct        places           in your ∗ Note : Remember that activity [0] is always January and always December ∗ ( This information                      also       holds      for          every other month) ∗ ∗ You can have Transactions with the same date ∗ ∗ @param rhs Account which take new Transactions from ∗ @return this Account after adding new Transactions ∗/ Account& operator+=(const Account& rhs) ; /∗∗ ∗ How much money Account has(Sum of                                     Transaction amounts) ∗ ∗ ∗ @return                 total amount of             the money of           the account ∗/ double balance() ; /∗∗ ∗ How much money Account has at the end of                                       given date ∗ ∗ Given date                  will           not be included .	activity                array			←–
	activity [11]		is
∗ @param end date You will count the amounts until this inclusive ) ∗ @return Total amount the Account has                                    until                 given date ∗/ double balance(time_t end_date) ; /∗∗ ∗ How much money Account between given dates ∗ Given dates will not be included . ∗	given	date ( not ←–

∗ @param end date You will count the amounts between given dates (not ←inclusive )

∗ @return Total amount the Account has between given      dates

∗ You will only count a Transaction amount i f and only i f it occured between←given dates ∗/ double balance(time_t start_date, time_t end_date) ;

/∗∗ ∗ Stream overload .

∗

∗

∗

∗ What to stream

∗ Id of          the user

∗ Earliest Transaction amount”tab”−”tab”hour : minute : second−day/month/year ( in←localtime )

∗ Second earliest Transaction amount”tab”−”tab”hour : minute : second−day/month/←year ( in localtime ) ∗ . . .

∗ Latest Transaction amount”tab−tab”hour : minute : second−day/month/year ( in ←localtime ) ∗

∗ Note : activity array will only contain dates from January 2019 to ←December 2019

∗ Note :               Transactions should be in                  order by date

∗ Note :        either       of            monthly activity frequency            or         activity        is              nullptr

∗ you will just stream ∗ −1

∗ @param os Stream to be used .

∗ @param Account to be streamed . ∗ @return the current Stream

∗/

friend std : : ostream& operator <<(std : : ostream& os,               const Account& account) ;

};

1.3           Bank

The bank keeps track of accounts.

class Bank { private :

std : : string _bank_name;

int _user_count;

Account∗ _users; public :

/∗∗

∗ Empty constructor

∗ give the bank name as ”not defined”

∗ give nullptr for pointers ∗ give 0 as users count

∗/ Bank() ;

/∗∗

∗ Constructor

∗

∗

∗ @param bankname name of              this bank

∗ @param userspointer to hold users of this bank ∗ @param usercount number of users this bank has ∗/ Bank(std : : string bank_name, Account∗ const users,         int user_count) ;

/∗∗

∗ Destructor

∗

∗ Do not    forget     to              free          the space you have created ( This assignment does not ←use smart pointers )

∗/ ˜Bank() ;

/∗∗

∗ Copy constructor (Deep copy)

∗

∗ @param rhs The Bank to be copied

∗/ Bank( const Bank& rhs) ;

/∗∗

∗ You should deep copy the content                 of         the second bank

∗ Merge two banks

∗ If both banks has a user with the same id , Transactions of these users ←will be merged in to the same Account ∗ For example :

∗ Bank1 has         [1 ,2]      id      users

∗ Bank2 has         [2 ,3]      id      users

∗

∗ Bank1 after += operator will have [1 ,2 ,3] id users ∗ User with id 2 will have its transactions histories merged

∗

∗ Transactions with of          the           users with the same id should be merged and ←updated

∗ @param rhs Merged Bank ∗ @return this Bank

∗/

Bank& operator+=(const Bank& rhs) ;

/∗∗

∗ Add a new account to Bank

∗

∗ If             the newly added user             already        exists       in       this Bank merge their ←–

Transactions

∗

∗ @param new acc new account to add to bank

∗ @return          this Bank

∗/

Bank& operator+=(const Account& new_acc) ;

/∗∗ Indexing          operator        overload

∗

∗ Return the Account with the given                  id

∗

∗ If        there                 is no Account with the given                id        return the              f i r s t element

∗

∗ @param account id         id     of        the Account

∗ @return                  i f              given      id              exist        in the bank return the account ,  else          return the ←f i r s t              account

∗

∗/

Account& operator [ ] ( int account_id) ;

/∗∗

∗ Stream overload . ∗    all         the accounts          will             be between 01−01−2019 and 31−12−2019 ∗ What to stream ∗ bank name”tab”number of                    users who are            eligible                  for a loan”tab” total ←–
balance      of       the bank ∗
∗ A user is safe for a loan i f and only i f that user did not negative balance for 2 or more consecutive months							have any ←–
∗ For example ,                                                let ‘ s say our bank named as ”banana” has two							users
∗
∗ User A’ s balance                   for              each month is ∗ ∗ January − 0 ∗ February − 0 ∗ March − 100 ∗ April − −20 ∗ May − −30 ∗ June − 40 ∗ July − 60 ∗ August − 0 ∗ September − 0 ∗ October − 0 ∗ November − 0 ∗ December − 0 ∗			as	given
∗ This user is not eligible because negative ( consecutive )			in	April and May his/her			balance	was ←–
∗ You s t i l l                    have to add 150 to the               total              balance					of       the	bank
∗ User B’ s balance                       for ∗ ∗ January − 0 ∗ February − 0 ∗ March − 100 ∗ April − −20 ∗ May − 40 ∗ June − −30 ∗ July − 60 ∗ August − 0 ∗ September − 0 ∗ October − 0 ∗ November − 0 ∗ December − 0 ∗	each month is               as given
∗ This user              is             eligible	because	negative                 balances			were	not consecutive
∗ You will                     also add 150 ∗	to the	total          balance      of       the bank
∗ your output               will       be as

∗ banana           1          300

∗/ friend std : : ostream& operator <<(std : : ostream& os,      const Bank& bank) ;

};

2             Extras

You have to check for memory leaks in your code. Any memory leak in certain class will result in point reduction.

You can test your code for any memory leak by using valgrind. (Provided MakeFile has valgrind option)

You can also test your implementation by using transaction test.cpp, account test.cpp, bank test.cpp, and compare your results with provided corresponding example *.txt files. (Some text editors might display tab character in a different format. To look at the output in the best way use gedit in Ubuntu,

TextEdit in Mac or just open it with vi)

Note: You can test your classes with (ouputs of these runs also given to you)

$ make transaction

$ make run

$ make valgrind

$ make account

$ make run

$ make valgrind

$ make bank

$ make run $ make valgrind