PROGRAM 14


//  FILE NAME:  PROG14.CPP     PROGRAMMMER NAME:  ANTHONY F. ORTIZ
//  THIS PROGRAM DISPLAYS AN ACCOUNT USER'S BALANCE AFTER AND BEFORE ONE
//  DEPOSIT AND ONE WITHDRAWAL.
#include 
#include 
#include "ouracct.h"
int main ()
{
    clrscr ();
    bankaccount justin ("SHMEAL", "0907", 500.00);
    cout << "BEFORE TRANSACTIONS, BALANCE IS " << justin.balance () << endl;
    justin.deposit (50.00);
    justin.withdraw (20.00);
    cout << endl << "AFTER TRANSACTIONS, BALANCE IS  " << justin.balance () << endl;
    return 0;
}

//  I DIDN'T WRITE OURACCT.H, OURACCT.CPP, OURSTUFF.H, AND OURSTUFF.CPP.

//  FILENAME:  OURACCT.H
//  THIS PROGRAM DECLARES A CLASS NAMED BANKACCOUNT.
#ifndef ouracct_h
#define ouracct_h
#include 
#include "ourstr.h"
class bankaccount
{
    public:
        bankaccount :: bankaccount ();
        //  POST:  OBJECT IS INITIALIZED WITH DEFAULTS WHEN CONSTRUCTED AS
        //         BANKACCOUNT ACCT1, ACCT2.
        //         THE STATE OF THESE OBJECTS (ACCT1 AND ACCT2) IS SET TO
        //         A DEFAULT STATE OF { BANKACCOUNT: ?NAME?, ?PIN?, 0.00 }.
        bankaccount :: bankaccount (const bankaccount & source);
        //  POST:  OBJECT IS COPIED DURING ARGUMENT/PARAMETER ASSOCIATIONS
        //         AND DURING A FUNCTION RETURN.  OBJECT IS ALSO INITIALIZED AS
        //         BANKACCOUNT ANOTHERACCT(ANACCT).        
        bankaccount :: bankaccount (string initname, string initpin);
        //  POST:  OBJECT IS INITIALIZED USING 2 ARGUMENTS WHEN CONSTRUCTED AS
        //         BANKACCOUNT ANOTHERACCT("JONES", "4321"), DEFAULT BALANCE = 0.        
        bankaccount :: bankaccount (string initname, string initpin, double initbalance);
        //  POST:  OBJECT IS INITIALIZED USING 3 ARGUMENTS WHEN CONSTRUCTED AS
        //         BANKACCOUNT ANOTHERACCT("JONES", "4321").        
        void bankaccount :: deposit (double amount);
        //  POST:  AMOUNT IS ADDED TO CURRENT BALANCE OF THE OBJECT.
        void bankaccount :: withdraw (double amount);
        //  POST:  AMOUNT IS DEDUCTED FROM THE CURRENT BALANCE OF THE OBJECT.
        double bankaccount :: balance () const;
        //  POST:  THE CURRENT BALANCE IS RETURNED.       
        string bankaccount :: name () const;
        //  POST:  THE NAME ATTRIBUTE IS RETURNED.       
        string bankaccount :: pin () const;
        //  POST:  THE PIN ATTRIBUTE IS RETURNED.    
    private:
        double accountbalance;
        string accountname;
        string accountpin;
};
ostream & operator << (ostream & os, bankaccount acct);
//  POST:  A BANKACCOUNT OBJECT IS DISPLAYED LIKE THIS:
//         { BANKACCOUNT, HALL, 1234, 100.00 }.
istream & operator >> (istream & is, bankaccount acct);
//  PRE:  THE NEXT THREE ITEMS ON THE INPUT STREAM ARE
//        STRING, STRING, NUMERIC LIKE THIS:
//        HALL  N234  100.00.
int operator == (bankaccount left, bankaccount right);
//  POST:  1 IS RETURNED IF THE TWO BANKACCOUNT OBJECTS HAVE THE SAME
//         EXACT NAME AND PIN VALUES (THE BALANCES MAY BE DIFFERENT).
//         0 IS RETURNED IF EITHER THE NAME OR PIN DIFFER.
#include "ouracct.cpp"
#endif

//  FILENAME:  OURACCT.CPP
//  THIS PROGRAM CONTAINS THE IMPLEMENTATION OF CLASS BANKACCOUNT.
#include "ourstr.h"
#include "ourstuff.h"
bankaccount :: bankaccount ()
{
    accountname = "?name?";
    accountpin = "?PIN?";
    accountbalance = 0.00;
}
bankaccount :: bankaccount (const bankaccount &source)
{
    accountbalance = source.accountbalance;
    accountpin = source.accountpin;
    accountname = source.accountname;
}
bankaccount :: bankaccount (string initname, string initpin)
{
    accountname = initname;
    accountname.toUpper ();
    accountpin = initpin;
    accountbalance = 0.00;
}
bankaccount :: bankaccount (string initname, string initpin, double initbalance)
{
    accountname = initname;
    accountname.toUpper ();
    accountpin = initpin;
    accountbalance = initbalance;
}
void bankaccount :: deposit (double amount)
{
    accountbalance = accountbalance + amount;
}
void bankaccount :: withdraw (double amount)
{
    accountbalance = accountbalance - amount;
}
string bankaccount :: name () const
{
    return accountname;
}
string bankaccount :: pin () const
{
    return accountpin;
}
double bankaccount :: balance () const
{
    return accountbalance;
}
ostream & operator << (ostream & os, bankaccount acct)
{
    long oldflags = decimals (os, 2);
    os << "{ bankaccount: "
    << acct.name () << ", "
    << acct.pin () << ", "
    << acct.balance ()
    << " }";
    os.flags (oldflags);
    return os;
}
istream & operator >> (istream & is, bankaccount & acct)
{
    string localname;
    string localpin;
    double localbalance;
    is >> localname >> localpin >> localbalance;
    is.ignore (72, '\n');
    acct = bankaccount (localname, localpin, localbalance);
    return is;
}
int operator == (bankaccount left, bankaccount right)
{
    if (left.name () == right.name ())
    {
        if (left.pin () == right.pin ())
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

//  FILENAME:  OURSTUFF.H
//  THIS FILE CONTAINS AN ASSORTMENT OF FUNCTIONS FOR USE WITH THE
//  TEXTBOOK 'COMPUTING FUNDAMENTALS WITH C++'.
#ifndef ourstuff_h
#define ourstuff_h
#include 
void clearscreen ();
//  POST:  THE COMPUTER SCREEN IS CLEARED. 
void causeapause ();
//  POST:  THE FUNCTION STOPS ONLY AFTER THE USER PRESSES ENTER.
//         ANY PREVIOUS CHARACTERS ARE IGNORED.
double round (double x);
//  POST:  RETURNS X ROUNDED TO THE NEARES INTEGER.
double round (double x, int n);
//   PRE:  N  >= 0.
//  POST:  RETURNS X ROUNDED TO N DECIMALS IF N > 0.
//         IF N IS 0, THE INTEGER NEAREST X IS RETURNED.
long decimals (ostream & os, int n);
//  POST:  ALL SUBSEQUENT OUTPUT OF FLOATS AND DOUBLES TO THE
//         OUTPUT STREAM (OS) IS DISPLAYED WITH EXACTLY N DECIMALS
//         USING TRAILING ZEROS IF NECESSARY.
void flush (istream & is);
//  POST:  THE INPUT STREAM OBJECT (IS IS USUALLY ASSOCIATED WITH CIN) SET BACK
//         TO A 'GOOD' STATE.  ALL EXTRANEOUS CHARACTERS ARE EXTRACTED FROM IS.
#include "ourstuff.cpp"
#endif

//  FILENAME:  OURSTUFF.CPP
//  THIS PROGRAM CONTAINS THE IMPLEMENTATION OF THE ASSORTMENT OF FUNCTIONS
//  IN OURSTUFF.H.
#include 
#include 
#include 
#include 
void clearscreen ()
{
    clrscr ();
}
void causeapause ()
{
    cout << "\n. . . PRESS ENTER TO CONTINUE . . . ";
    cout.flush ();
    getchar ();
}
double round (double x)
{
    return ceil (x - 0.5);
}
double round (double x, int n)
{
    if (n < 0)
        return x;
    else
    {
        double factor = pow (10.0, n);
        return ceil (x * factor - 0.5) / factor;
    }
}
static long defaultflags = cout.flags ();
static int defaultprecision = cout.precision ();
static long int default_x_flags = cout.setf (0);
long decimals (ostream & cout, int n)
{
    long oldflags = cout.flags ();
    if (n == 0)
    {
        cout.flags (defaultflags);
        cout.precision (defaultprecision);
        cout.setf (default_x_flags);
    }
    else if (n > 0)
    {
        cout.setf (ios :: fixed, ios :: floatfield);
        cout.setf (ios :: showpoint);
        cout.precision (n);
    }
    return oldflags;
}
void flush (istream & is)
{
    is.clear ();
    char nextchar;
    while ((nextchar = is.get ()) != '\n' && nextchar != EOF) {}
    is.clear ();
}

//  FILENAME:  OURSTR.H, OURSTR.CPP
//  SEE PROGRAM 12.

//  OUTFILE:  PROG14.OUT

BEFORE TRANSACTIONS, BALANCE IS 500
                                                                                
AFTER TRANSACTIONS, BALANCE IS  530




BACK TO COMP251 PAGE.