New Page 1

Working with C++ Classes

reading: Deitel chapter 6

Time Structure in C

typedef struct
{
    int hours;
    int minutes;
    int seconds;
} Time;

void InitTime (Time* tp, int h, int m, int s); /* Must call to set up new variables */

void PrintMilitary (const Time* tp);           /* Access all three fields */

void PrintStd (const Time* tp);

void IncrementHour (Time* tp, int h);            /* Change hours field */
void IncrementMinutes (Time* tp, int m);       /* Change seconds field */
void IncrementSeconds (Time* tp, int s);       /* Change minutes field */

Time Class in C++

class Time {

public:

        Time ( );                            // constructor to initialize to default time
        Time ( int h, int m, int s );   // constructor to initialize to any time

        void PrintMilitary ( void ) const;      // no need to pass parameter;
        void PrintStd ( void ) const;               //   object will be accessed automatically
        void SetTime ( int h, int m, int s );    // change all fields
        void IncrementHour ( int h );           // change hours field
        void IncrementMinute ( int m );        // change minutes field
        void IncrementSecond ( int s );       // change seconds field
        int GetHour ( void ) const;                 // access hours field
        int GetMinute ( void ) const;             // access minutes field
        int GetSecond ( void ) const;           // access seconds field

private:

        int hours;    // only member functions can see these fields
        int minutes;   // prevents erroneous access / changes

        int seconds;

}

Some Terminology

Time is a class; instantiations are objects

private, public: "access specifications" (also protected; default is private)

hours, minutes, seconds: data members / fields
    For 202: all fields of all classes to be private

Time(), PrintMilitary(), IncrementHours(), etc.: member functions / member methods

Member functions can access private fields:

void Time :: PrintMilitary ( void )   // scope resolution operator ::

{                                             // define member functions in class file (.cpp)

    cout << (hours < 10 ? "0" : "") << hours;

    cout << ":"

    cout << (minutes < 10 ? "0" : "") << minutes;

}

Member functions can also change private fields:

void Time :: SetTime (int h, int m, int s)

{

    hours = h;    // implicit reference to object on which function was called

    minutes = m;

    seconds = s;   // should check legality of parameters

}

Non-member functions cannot do either:

void main ( )

{

    Time t; // no-argument constructor called

   t.minutes = 11;             // both compiler errors
     cout << "The hour is: " << t.hours;

}

Data Access and Manipulation

Accessor functions: GetHour(), GetMinute(), GetSecond(), etc.

Mutator functions: SetTime(), SetHour(), SetMinute(), SetSecond(), etc.

Preserve information hiding

Constructors

Automatically called upon variable declaration

Guarantees correct initialization

Can have multiple constructors; whichever matches argument list is called
    (no matching argument list: compiler error)

Must have same name as class; must not have return type (not even void)

One provided by compiler only if none explicitly written

Examples:

Time :: Time ( void )
{
    hours = minutes = seconds = 0;
}

Time :: Time ( int h, int m, int s )
{
    hours = ( 0 <= h ) ? h%24 : 0;
    minutes = ( 0 <= m ) ? m%60 : 0;
    seconds = ( 0 <= s ) ? s%60 : 0;
}

Default Arguments

Can be used with any function

Specified in prototype

Specify values for missing parameters; all defaults must follow all non-defaults

void Time :: SetTime ( int h, int m = 0, int s = 0); // can omit s or m, s within call
t . SetTime ( 9 ); // time is now 9:00:00

Careful: compiler must be able to distinguish function calls

void Time :: SetTime ( int h, int m );
void Time :: SetTime ( int h, int m = 0, int s = 0 );

t . SetTime ( 8, 7 ); // both prototypes consistent with call; cannot be resolved

Destructors

Opposite of constructors

Automatically called when object goes out of scope

Perform clean-up (usually to free dynamically-allocated memory)

Can have only one per class

Must be named ~<classname>; must have no return type (not even void)

Default destructor provided by compiler; not always sufficient (pointers, etc.)

Composition (Aggregation)

Class members may be of class types (a Date could contain a Time, etc.)

Common example of code reuse

this pointer

Each object can access its address

Implicitly used when referencing members of the object on which a function is called

Can also be used explicitly
void Time :: SetMinute ( int m )
{ this -> minutes = m; }

Implicitly passed as first argument of every non-static member function

We'll see more useful examples later

Use of const

Should be used wherever possible to prevent incorrect data modification

Objects, functions, and function parameters can all be const

const objects

const Time EightFifteen(8, 15, 0);

EightFifteen is now 8:15:00 and cannot be modified

const functions

void PrintMilitary ( void ); does not modify Time object it's called on
    compiler won't automatically detect this

declare: void PrintMilitary ( void ) const;
    compiler checks that Time object's fields are not modified

now we could call: EightFifteen.PrintMilitary ( );

const functions can be invoked on any (appropriate) object

non-const functions can only be invoked on non-const objects

constructors and destructors cannot be const

accessors should be const, mutators non-const

const function parameters

const parameters cannot be modified

use with references (call-by-reference; avoid large parameter copying) :
    void SetTime ( const Time& old_time );
    now old_time is not copied, but cannot be modified

non-const objects can always be passed as parameters

const objects can only be passed as const reference parameters

now we could call: Time t2 = SetTime ( EightFifteen ); (without copying EightFifteen)

Separating Interface and Implementation

Interface: header file ( Time.h )

Given to the user

Substantial user-oriented documentation

Class definition (including member function prototypes)

Generally, no member function definitions

Implementation: class file ( Time.cpp )

Only for programmer

Programmer-oriented documentation

Definitions of member functions (use scope resolution)

Good Programming Practice

Use private, public only once per class definition

List public section first within definition

All fields private

Declare functions, parameters const where appropriate