OOP Course

STRUCTS
1. Brief review of key concepts and terminology of object-oriented programming:

2. OOP encapsulates data (attributes) and functions (behaviors) into packages called
objects; the data and functions of an object are intimately tied together.

3. Objects have the property of information hiding.

a) Although objects may know how to communicate with one another across well-
defined interfaces, objects normally are not allowed to know how other objects
are implemented--implementation details are hidden within the objects
themselves.
b) An analogy would be that it is possible to drive a car effectively without
knowing the details of how engines, transmissions and exhaust systems work
internally.
c) Information hiding is crucial to good software engineering.

4. Comparison of C and other procedural programming languages to C++:

a) In C, programming tends to be action-oriented, whereas ideally in C++
programming is object-oriented.
b) In C, the unit of programming is the function. In C++, the unit of programming
is the class from which objects are eventually instantiated (i.e. created).
c) C programmers concentrate on writing functions.
i) Groups of actions that perform some task are formed into functions, and
functions are grouped to form programs.
ii) Data exists primarily in support of the actions that functions perform.
iii) The verbs in a system specification help the C programmer determine the
set of functions that will work together to implement the system.
 OOP Course
STRUCTS AND CLASSES (CONTINUED)

d) C++ programmers concentrate on creating their own user-defined types called

classes. Classes are also referred to as programmer-defined types or abstract
data types (ADTs).
i) Each class contains data as well as the set of functions that manipulate the
data.
a) The data components of a class are called data members.
b) The function components of a class are called member functions.
ii) Just as an instance of a built-in type such as int is called a variable, an
instance of a user-defined type (i.e. a class) is called an object.
iii) The focus of attention in C++ is on objects rather than functions.
iv) The nouns in a system specification help the C++ programmer determine
a set of classes. These classes are used to create objects that will work
together to implement the system.

5. Classes in C++ are a natural evolution of the C notion of struct.

 OOP Course
STRUCTURES

1. Structures are aggregate data types built using things of other types.
a) Example of a structure definition:

struct Time {
int hour;
int minute;
int second;
};

b) The keyword struct introduces the structure definition.

c) The identifier Time is the structure tag. The structure tag names the structure
definition and is used to declare variables of the structure type, for example, the
type name Time.
d) The names declared in the braces of the structure definition are the structure's
members.
i) Members of the same structure must have unique names, but two different
structures may contain members of the same name without conflict.
e) Each structure name must end with a semi-colon.
f) A structure cannot contain an instance of itself.
i) For example, a member of type Time cannot be declared in the structure
definition for Time.
ii) A pointer to another Time structure can be included within Time's
structure definition.
a) A structure containing a member that is a pointer to the same
structure type is referred to as a self-referential structure.
b) Self-referential structures are useful for forming linked data
structures.
g) A structure definition does not reserve any space in memory.
i) The definition creates a new data type that is used to declare variables.
ii) Structure variables are declared in the following manner:
a) Time timeObject; // a variable of type Time
b) Time timeArray[10]; // an array of 10 elements of
// type Time
c) Time *timePtr; // a pointer to a Time Object
 OOP Course
STRUCTURES (CONTINUED)

2. Accessing members of structures

a) Members of a structure (or of a class) are accessed using the member access
operators.
i) The dot operator (.) accesses a structure (or class) member via the variable
name for the object or via a reference to the object.
a) To print a member hour of structure timeObject:

Time timeObject;
...
cout << timeObject.hour;

ii) The arrow operator (->), consisting of a minus (-) sign followed by a
greater than (>) sign with no intervening spaces, accesses a structure (or
class) member via a pointer to the object.
a) To print member hour of structure timeObject with pointer timePtr:

Time timeObject;
Time *timePtr = &timeObject;
...
cout << timePtr->hour;

b) The expression timePtr->hour is equivalent to (*timePtr).hour

which dereferences the pointer and accesses the member hour using
the dot operator.
(1) The parentheses are needed here because the dot operator (.)
has a higher precedence than the pointer dereferencing
operator (*).
(2) The arrow operator and structure member operator, along
with parentheses and brackets ( [] ), have the second highest
operator precedence (after the scope resolution operator to be
discussed later).

3. The preceding rules for structures apply to classes as well.

 OOP Course
STRUCTURES (CONTINUED)

4. Problems with C-style structures:

a) Initialization is not required so it is possible to have uninitialized data.
b) The data can be manipulated directly by the programmer; there is no "interface"
to it to protect the data and ensure the programmer uses the data type correctly
and to ensure that the data remains in a consistent state.
c) Structures cannot be printed as a unit, rather their members must be printed and
formatted one at a time. A function could be written to print the members of a
structure in some appropriate format.
d) Structures may not be compared in their entirety; they must be compared
member by member.
 OOP Course
IMPLEMENTING A USER-DEFINED TYPE TIME WITH A STRUCT

1. The following program:

a) Creates the user-defined structure type Time with three integer members: hour,
minute, and second.
b) Defines a single Time structure called dinnerTime and uses the dot operator to
initialize the structure members.
c) Prints the time in military format and standard format.
i) Note that the print functions receive references to const Time structures.
a) This causes the Time structures to be passed to the print functions
by reference, thus eliminating the copying overhead associated with
passing structures to functions by value.
b) const is used to prevent the Time structure from being modified by
the print functions.

// Create a structure, set its members, and print it.

#include <iostream.h>

struct Time { // structure definition

int hour;
int minute;
int second;
};

void printMilitary(const Time &); // prototype

void printStandard(const Time &); // prototype
 OOP Course
IMPLEMENTING A USER-DEFINED TYPE TIME WITH A STRUCTURE

main()
{
Time dinnerTime; // variable of new type Time

// set members to valid values

dinnerTime.hour = 18;
dinnerTime.minute = 30;
dinnerTime.second = 0;

cout << "Dinner will be held at ";

printMilitary(dinnerTime);
cout << " military time," << endl << "which is ";
printStandard(dinnerTime);
cout << " standard time." << endl;

// set members to invalid values

dinnerTime.hour = 29;
dinnerTime.minute = 73;
dinnerTime.second = 103;

cout << endl << "Time with invalid values: ";

printMilitary(dinnerTime);
cout << endl;
return 0;
}

// Print the time in military format

void printMilitary(const Time &t)
{
cout << (t.hour < 10 ? "0" : "") << t.hour << ":"
<< (t.minute < 10 ? "0" : "") << t.minute << ":"
<< (t.second < 10 ? "0" : "") << t.second;
}
 OOP Course
IMPLEMENTING A USER-DEFINED TYPE TIME WITH A STRUCTURE

// Print the time in standard format

void printStandard(const Time &t)
{
cout << ((t.hour == 0 || t.hour == 12) ? 12 : t.hour % 12)
<< ":" << (t.minute < 10 ? "0" : "") << t.minute
<< ":" << (t.second < 10 ? "0" : "") << t.second
<< (t.hour < 12 ? " AM" : " PM");
}

Output is:

Dinner will be held at 18:30:00 military time,

which is 6:30:00 PM standard time.

Time with invalid values: 29:73:103