2.6 Introduction to classes  (Page 2/9)

The public access specifier allows anyone to call a class’s function member or to modify a data member.

The private access specifier is one of the key elements in information hiding since it prevents clients from calling member functions or accessing data members.

Both public and private specifiers have what is called class scope : class members of both access types are accessible from any of a class’s member functions.

Example:

class Time {

public:

Time();

void setTime( int, int, int );

void printMilitary();

void printStandard();

private:

int hour;

int minute;

int second;

};

Note that the data members hour, minute, and second are preceded by the private member access specifier. A class’ private data members are normally not accessible outside the class. The philosophy here is that the actual data representation used within the class is of no concern to the class’ clients. In this sense, the implementation of a class is said to be hidden from its clients. Such information hiding promotes program modifiability and simplifies the client’s perception of a class.

You can depict the classes graphically in a class diagram as below.

The diagram shown above follows the format of the Unified Modeling Language (UML). Each class is represented by a box, with the class name in the top portion of the box, any data members that you care to describe in the middle portion of the box, and the member functions (the functions that belong to this object, which receive any messages you send to that object) in the bottom portion of the box.

Interface and implementation files

Although the first step in information hiding is to assign private access specifiers to class members, private access specifiers only designate which class members a client is not allowed to call or change. Private access specifiers do not prevent clients from seeing class code. To prevent clients from seeing the details of how your code is written, you place your class’s interface code and implementation code in separate files.

The separation of classes into separate interface and implementation files is considered to be a fundamental software development technique since it allows you to hide the details of how your classes are written and makes it easier to modify programs.

The interface code refers to the data member and function member declarations inside a class’s braces. Interface code does not usually contain definitions for function members, nor does it usually assigns values to the data members. You create interface code in a header file with an .h extension.

The implementation code refers to a class’s function definitions and any code that assigns values to a class’s data members. In other words, implementation code contains the actual member functions themselves and assigns values to data members. You add implementation code to standard C++ source files with an extension of .cpp.

As far as clients of a class are concerned, changes in the class’ implementation do not affect the client as long as the class’ interface originally provided to the client is unchanged. All that a client needs to know to use the class correctly should be provided by the interface.