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 << (hour < 10 ? “0” : “”) << hour;

    cout << “:”

    cout << (minute < 10 ? “0” : “”) << minute;

}

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
  
  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
  
  Time :: SetTime ( int h, int m );
  Time :: SetTime ( int h, int m = 0, int s = 0 );
  
  t . SetTime ( 8, 7 );      // both prototypes consistent with call; cannot be resolved

Initialization Lists

• Used by constructors
• Sets fields to parameters
• Calls constructor on each parameter first
• Necessary for fields (of class types) without parameterless constructors

Syntax:

Time :: Time ( int h, int m, int s ) : hours ( h ), minutes ( m ), seconds ( s ) {}

explicitly invokes constructors for hours, minutes, seconds

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.)

Assignment Operators and Copy Constructors

• One of each provided by default for every class
• Specify how an object is to be copied into another object
• Simple member-wise copy in default
• Not always sufficient (pointers, etc.)
• Can overrride (more later)
• Assignment operators called on = (except initializations): 
      Time t1(8), t2(7,3,6); t1 = t2;
      may have to do clean-up on original object (similar to destructor)
• Copy constructors called on "copy initializations" :
     Time t1(8,7,6); Time t2(t1);  Time t3 = t1;
      no clean-up necessary; object initially "blank"
       

Composition (Aggregation)

• Class members may be of class types (a Date could contain a Time, etc.)
• Constructors are called for any such members at construction of object
      specify in initialization list, or else default (parameterless) constructors are called
• 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 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
• Use initialization lists where appropriate