Lecture Notes. Day One

From Structure to Class

In C: you concentrate on writing functions: Groups of actions for performing some task are formed into functions; Functions are grouped to form programs. Data plays primarily a supportive role for performing the actions.

In C++: you concentrate on creating your own user-defined types, or, classes. Data and a set of functions that manipulate the data form a class. The data components: data members. The function components: member functions. An instance of a built-in type can be called a variable, an instance of a class is called an object.

class in C++ is a natural evolution of the C notion of struct. After getting an acquaintance with classes, you will realize, that structures in C++ are classes with public members only.

C structure, which simply prints in a time format, is given below:

  1. // time_struct_1.cpp

  2. #include <iostream.h>

  3. struct Time    // key word "struct"

  4. {

  5.    int hour;

  6.    int minute;

  7.    int second;

  8. };


  10. void print(const Time &);

  11. main()

  12. {

  13.    Time t; // a variable of type Time is declared...

  14.    // access of structure members with a structure object:

  15.    t.hour = 19;

  16.    t.minute=1;

  17.    t.second=38;

  18.    cout << "You entered time as ";

  19.    print(t);


  21.    return 0;

  22. }


  24. void print(const Time &t)

  25. {

  26.    cout << ( (t.hour == 0 || t.hour == 12) ? 12 : t.hour % 12 )

  27.         << ":" << ( t.minute < 10 ? "0" : "") << t.minute

  28.         << ":" << ( t.second < 10 ? "0" : "") << t.second

  29.         << (t.hour < 12 ? " AM" : " PM");

  30. }

In this program we meet with the conditional operator, the only ternary operator in C++, which takes three operands. The argument of a print function, which is evidently of type void, is a const reference to the structure type Time. It is elegant to call for the Time variable via reference, and safety, because this is const.

Let us make a step towards a class-like style:

  1. // time_struct_2.cpp

  2. #include <iostream.h>

  3. struct Time   

  4. {

  5.    void print();

  6.    void setTime(int, int, int);

  7.    int hr;

  8.    int mn;

  9.    int sc;

  10. };


  12. main()

  13. {

  14.    Time t; // a variable of type Time is declared...

  15.    t.setTime(19,1,38);

  16.    cout << "You entered time as ";

  17.    t.print();

  18.    t.setTime(4,59,79);

  19.    cout << "... and now as ";

  20.    t.print();


  22.    return 0;

  23. }


  25. void Time::setTime(int h, int m, int s)

  26. {

  27.    hr = h;

  28.    mn = m;

  29.    sc = s;

  30. }


  32. void Time::print()

  33. {

  34.    cout << ( (hr == 0 || hr == 12) ? 12 : hr % 12 )

  35.         << ":" << ( mn < 10 ? "0" : "") << mn

  36.         << ":" << ( sc < 10 ? "0" : "") << sc

  37.         << (hr < 12 ? " AM" : " PM");

  38. }

What's a difference? We included print into the member functions of structure Time, and instead of setting time through the Time variable t, we set it with using setTime. This allows us to get a direct access to other Time members, hr, mn, sc.

Exercize:

Think about what changes should be done in the program for initializing objects in Standard Time format: hr:mn:sc:am(pm)

Now, if we wish to arrive at the same functionality in terms of Class Time, the changes are really minimal. In the code below you meet with a new special function Time(), which is a constructor function. Old, but new elements now are data members, which are declared private. Before, being the structure members, they were accessible via a structure variable (object). The interface is different now: the private data members are seen by the public member functions. Also, we delegate an additional control functionality to setTime public member in order to disallow such misprints as in time_struct_2.cpp.

  1. // time_class_1.cpp

  2. #include <iostream.h>


  4. class Time

  5. {

  6. public:

  7.    Time(); // new element: constructor

  8.    void setTime(int, int, int);

  9.    void print();

  10. private:

  11.    int hr;

  12.    int mn;

  13.    int sc;

  14. };

  15. // Time constructor initializes data members to zero

  16. // which will be printed as 12 AM

  17. Time::Time() { hr = mn = sc = 0; }


  19. void Time::setTime(int h, int m, int s) // improved...

  20. {

  21.    hr = (h >=0 && h < 24) ? h : 0;

  22.    mn = (m >=0 && m < 60) ? m : 0;

  23.    sc = (s >=0 && s < 60) ? s : 0;

  24. }

  25. void Time::print()

  26. {

  27.    cout << ( (hr == 0 || hr == 12) ? 12 : hr % 12 )

  28.         << ":" << ( mn < 10 ? "0" : "") << mn

  29.         << ":" << ( sc < 10 ? "0" : "") << sc

  30.         << (hr < 12 ? " AM" : " PM");

  31. }

  32. main()

  33. {

  34.    Time t; // a variable of type Time is declared...

  35.    t.setTime(19,1,38);

  36.    cout << "You entered time as ";

  37.    t.print();

  38.    t.setTime(4,59,79);

  39.    cout << "... and now as ";

  40.    t.print();


  42.    return 0;

  43. }

The output should be like this:

   You entered time as 7:01:38 PM
   ... and now as 4:59:00 AM

Even such a short code becomes more readable, if their parts are re-arranged into header, source file and driver (that is a common place of C, too):

Header: Declarations & Class Definition

  1. // time_class_1.h

  2. #ifndef TIME_CLASS_1_H

  3. #define TIME_CLASS_1_H


  5. class Time

  6. {

  7. public:

  8.    Time();

  9.    void setTime(int, int, int);

  10.    void print();

  11. private:

  12.    int hr;

  13.    int mn;

  14.    int sc;

  15. };

  16. #endif

The following directive defines header file TIME_CLASS_1_H: #define TIME_CLASS_1_H. This means that the compiler's preprocessor puts TIME_CLASS_1_H on a list to indicate that it has been seen. The next directive, #ifndef TIME_CLASS_1_H, tests to see whether TIME_CLASS_1_H has been defined. If defined, then everything between this directive and #endif will be skipped. Why it is necessary to do? That is because C++ does not allow you to define a class more than once. In the code below we shall use the include directive #include "time_class_1.h" twice, and with no problems: the class will be defined only one time.

Source file: Constructor, member functions, etc.

  1. // time_class_1.cpp

  2. #include <iostream.h>

  3. #include "time_class_1.h"


  5. Time::Time() { hr = mn = sc = 0; }


  7. void Time::setTime(int h,int m,int s)

  8. {

  9.    hr = (h >=0 && h < 24) ? h : 0;

  10.    mn = (m >=0 && m < 60) ? m : 0;

  11.    sc = (s >=0 && s < 60) ? s : 0;

  12. }

  13. void Time::print()

  14. {

  15.    cout << ( (hr == 0 || hr == 12) ? 12 : hr % 12 )

  16.         << ":" << ( mn < 10 ? "0" : "") << mn

  17.         << ":" << ( sc < 10 ? "0" : "") << sc

  18.         << (hr < 12 ? " AM" : " PM");

  19. }

Main, or, driver for testing:

  1. // time_main_1.cpp

  2. #include <iostream.h>

  3. #include "time_class_1.h"


  5. main()

  6. {

  7.    Time t; // instantiate object of class Time


  9.    t.setTime(19,1,38);

  10.    cout << "You entered time as ";

  11.    t.print();

  12.    t.setTime(4,59,79);

  13.    cout << "... and now as ";

  14.    t.print();


  16.    return 0;

  17. }

How to compile and execute them? You can create a makefile based on the commands:

  >g++ -c time_class_1.cpp time_class_1.h
  >g++ -c time_main_1.cpp time_class_1.h
  >g++ -o time_class time_class_1.o time_main_1.o
  >time_class

The member access specifiers public and private are used to control access to a class’ data members and member functions.

Private class members can be only accessed by member functions (and friend functions) of the class.
Public class members may be accessed by any function in the program.

Initializing Class Objects: Constructors

Constructor: a class member function with the same name as the class name.
Constructor is automatically invoked each time an object of the class is created

Performance can be improved with using a default constructor.
Compare the left column with its right counterpart.

class Time
{
public:
   Time();
......
Time::Time() { hr=mn=sc=0; } 		class Time
{
public:
   Time(int = 0, int = 0, int = 0);
......
Time::Time(int hr, int mn, int sc)
{ setTime(hr, mn, sc); }

Then, instead of formal setting of time with setTime as, for example, t.setTime(14,31,68), it will be possible to set data members “directly” via t(14,31,68). Then, t(14,31) means t(14,31,0), t(14) means t(14,0,0), t means t(0,0,0).
So, main() in time_main_1.cpp could be re-written like this:


  2. #include <iostream.h>

  3. #include “time_class_1.h”


  5. main()

  6. {

  7.    Time t1(19,1,38), t2(4,59,79);


  9.    cout << "You entered time as ";

  10.    t1.print();

  11.    cout << "... and now as ";

  12.    t2.print();


  14.    return 0;

  15. }

Using Destructors:

Name for the destructor: ~ClassName()
Destructor’s task: not to destroy the object, but terminate housekeeping before the system reclaims the object’s memory space.

Destructors are the proper functions for classes whose objects contain dynamically allocated storage.

Example of Constructor & Destructors hierarchies

  1. // create_and_destroy.h

  2. // Definition of Class CREATURES

  3. #ifndef CREATE_AND_DESTROY_H

  4. #define CREATE_AND_DESTROY_H

  5. // user-defined enumeration type:

  6. enum NUMBER{GLOBAL,LOCMN1,STATMN,LOCFN1,STATFN,LOCFN2,LOCM2};

  7. class Creatures

  8. {

  9. public:

  10.    Creatures(NUMBER); // constructor

  11.    ~Creatures();     // destructor

  12. private:

  13.    NUMBER creatureNumber;

  14. };

  15. #endif

  1. // create_and_destroy.cpp

  2. #include <iostream.h>

  3. #include "create_and_destroy.h"

  4. Creatures::Creatures(NUMBER value)

  5. {

  6.    creatureNumber = value;

  7.    cout << "Make a Creature # " << value;

  8. }

  9. Creatures::~Creatures()

  10. {

  11.    cout << "Destroy a Creature # " << value;

  12. }

  1. // create_and_destroy_test.cpp

  2. #include <iostream.h>

  3. #include "create_and_destroy.h"

  4. void create();

  5. Creatures cr0(GLOBAL);

  6. main()

  7. {

  8.    cout << "(global object created before main)" << endl;

  9.    Creatures cr1(LOCMN1);

  10.    cout << "(local object created in main)" << endl;

  11.    static Creatures cr2(STATMN);

  12.    cout << "(static object created in main)" << endl;

  13.    create();

  14.    Creatures cr6(LOCMN2);

  15.    cout << "(local object created in main)" << endl;

  16.    return 0;

  17. }


  19. void create()

  20. {

  21.    Creatures cr3(LOCFN1);

  22.    cout << "(local object created in create)" << endl;

  23.    static Creatures cr4(STATFN);

  24.    cout << "(static object created in create)" << endl;

  25.    Creatures cr5(LOCFN2);

  26.    cout << "(local object created in create)" << endl;

  27. }

The first column includes the object’s numbers in order of their occurence in create_and_destroy_test.cpp. Please, before executing a program, fill the second column with the numbers in order of the same object’s destruction.

NUMBER is a user-defined type called an enumeration. Very efficient in combination with the switch statement.

Local variable declared with the keyword static is known only in function in which it is defined. static local variable retains its value when the function is exited. When the function is called next time, static local variable contains the value at the moment of function's last exiting.

Exercize:

Add new functionalies to our Time class.

  1. In setTime: a possibility to set Time from a keybord, including an elementary dialog, like this: "Set hours in London: ",..., "Set minutes in London at Big Ben: ",..., etc.

  2. Use the print functions, first, printTimeInLondon() whose output would be "Local time in London hr:mn:sc AM(PM) of today", second, printTimeInBoston() with a sort of the output like this: "Local time in Boston hr:mn:sc AM(PM) of today(yesterday)"

  3. Optional: Instead of today-yesterady identification of the date, think how to set a current date in London and Boston and send the information to the output in the following format: "Local time in London hr:mn:sc AM(PM) of mm/dd/yy" & "Local time in Boston hr:mn:sc AM(PM) of mm/dd/yy".
1