3. More about Data Structures and ADTs: C++ data types

(1)

3. More about Data Structures and ADTs:

C++ data types

C++ types an be classified as:

• Fundamental (or simple or scalar):

A data object of one of these types is a single object.

- int, double, char, bool, complex,

and the related types (unsigned, short, etc.) - enumerations

• Structured:

Collections of data

- arrays, structs, unions, classes, valarrays, bitsets,

the containers and adapters in STL

(2)

Structs vs. Classes

Similarities

1. Essentially the ________________________

2. Both are used to model objects with

_ (characteristics) represented as _____ (also called fields or instance variables or attribute variables).

Thus, both are used to process non-homogeneous

data sets.

(3)

3

Structs vs. Classes

Differences

1. C does not provide classes;

C++ provides both structs and classes.

2. Members of a struct by default are ___________

(can be accessed outside the struct by using the the dot operator.

In C++ they can be declared to be __________

(cannot be accessed outside the struct.

3. Members of a class by default are ___________

(cannot be accessed outside the class) but can be

explicitly declared

(4)

C++'s structs and classes model objects that have:



Attributes (characteristics) represented as _________________

and



Operations (behaviors) represented as ____________________

(also called methods).

C Structs vs. C++ Classes (&

Structs)

( "traditional" vs "OOP")

This leads to a whole new style of programming: object-oriented.

Objects are _, possessing their own operations — commonly called the ________principle —

rather than being passed as a parameter

(5)

Declaring a Class

Common Forms:

class ClassName {

// private by default

Declarations of private members public:

Declarations of public members };

class ClassName {

public: //"interface" of class given first Declarations of public members

private:

Declarations of private members

(6)

Notes:

Data members are normally placed in the private section of a class;

function members in the public section.

Attributes Data Members Operations

Function Members

Some programmers prefer to put the private section first:

- Using the default access for classes - Can omit the private: specifier

Other programmers put the public interface of the class first and the hidden private details last. (In the text, the latter approach is used.)

Although not commonly done, a class may have several

private and public sections; the keywords private:

(7)

Access to Class Members

A particular instance of a class is called an _____________:

ClassName object_name;

Private members can be accessed

______________ (except by functions to be described later).

Public members can be accessed ___________________________

_; to access them outside the class, one must use the _____:

object_name.public_member_name

Class declarations are usually placed in a header

file whose name is ClassName.h . The library is

(8)

Header file for class Time — Version 1

/** Time.h --- This header file defines the data type Time for processing time Basic operations are:

Set: To set the time

Display: To display the time

---*/

#include <iostream>

using namespace std;

class Time

{/******** Member functions ********/

public:

/* Set sets the data members of a Time object to specified values.

* * Receive: hours, the number of hours in standard time

* minutes, the number of minutes in standard time * AMPM ('A' if AM, 'P' if PM

* Return: The Time object containing this function with its

* myHours, myMinutes, and myAMorPM members set to hours, * minutes, and am_pm, respectively, and myMilTime to

(9)

9

/* Display displays time in standard and military format using * output stream out.

* * Receive: ostream out

* Output: The time represented by the Time object containing * this function

* Passes back: The ostream out with time inserted into it

*****************************************************************/

void Display(ostream & out) const;

/********** Data Members **********/

____________

unsigned ______________, _______________;

char _______________; // 'A' or 'P'

unsigned _______________; // military time equivalent }; // end of class declaration

Notes:

1. "my" in data members names remind of internal ("I can do it myself") perspective.

2. const at end of Display()'s prototype makes it a ___________________________

whieh means it

(10)

10

3. Why make data members private?

"Hidden" data members:



Cannot be accessed outside class



Application programs must interact with an object through its _____________



________________________ control interaction between programs and class.



Application program need not know about implementation!

 Implementation may___________ (improve storage, simpler algorithms.

etc.)

 If interface is constant, programs using an object ____________________.

What's wrong with tying application code to implementation details?



A change in implementation forces a change in the application code  Increased upgrade time.

 Increased programmer cost

 Decreased programmer productivity  Reduced profits due to

— Delayed releases/upgrades

(11)

Implementation of a Class

Class declaration contains:

• Declarations of data members

• Prototypes (declarations) of function members

Definitions of function members are not usually placed in class declaration  Avoid cluttering up the interface

Definitions placed outside the class declaration must tell compiler where the corresponding declaration/prototype is:

Use the _which has the form ____________

(the____or name of ItemName.)

(12)

Example

:

class Something {

public:

____________ const int CAPACITY = 100;

typedef double ArrayType[CAPACITY];

void Print(ArrayType a, int itsSize);

. . . }

. . .

Something::ArrayType x = {0};

for (int i = 0; i < Something::CAPACITY; i++) . . .

void Something::Print(Something::ArrayType a,

int itsSize)

(13)

Traditionally, definitions of member functions have been put in an implementation file ClassName.cpp corresponding to the class' header file. This is done to enforce _________________________

_____________________________________________________.

(Unfortunately, the class data members, which store data and are therefore part of the implementation, must be in the .h file.)

With the increasing use of ______________, however, this practice is becoming less common because current compiler technology

doesn't permit this split for templates — everything has to be in the

same file. Thus the reason for dropping the ".h" from standard

class libraries. They're really class-template libraries, and there are

therefore no corresponding ".cpp" files.

(14)

Implementation of class Time — Version 1

// Time.cpp -- implements the Time member functions _____________________________

/*** Utility functions ***/

/* ToMilitary converts standard time to military time.

Receive: hours, minutes, am_pm

Return: The military time equivalent

Could implement this as a private class method

*/

int ToMilitary (unsigned hours, unsigned minutes, char am_pm) {

if (hours == 12) hours = 0;

return hours * 100 + minutes + (am_pm == 'P' ? 1200 : 0);

(15)

Implementation of class Time — cont.

//--- Function to implement the Set operation

void ____________(unsigned hours, unsigned minutes, char am_pm) {

// Check _____________________________

if (hours >= 1 && hours <= 12 &&

minutes >= 0 && minutes <= 59 &&

(am_pm == 'A' || am_pm == 'P')) {

myHours = hours;

myMinutes = minutes;

myAMorPM = am_pm;

myMilTime = ToMilitary(hours, minutes, am_pm);

} else

cerr << "*** Can't set time with these values ***\n";

// Object's data members remain unchanged }

(16)

//--- Function to implement the Display operation void ________________(ostream & out) ____________

{

out << myHours << ':'

<< (myMinutes < 10 ? "0" : "") << myMinutes << ' ' << myAMorPM << ".M. ("

<< myMilTime << " mil. time)";

}

Implementation of class Time — cont.

(17)

Test driver for class Time

#include "Time.h"

#include <iostream>

using namespace std;

int main()

{ _____________________________;

_______________________________________________;

cout << "We'll be eating at ";

_______________________________________________;

cout << endl;

}

Execution:

We'll be eating at 5:30 P.M. (1730 mil. time)

(18)

Object-Oriented Perspective

Procedural: Send object off to some function for processing

OOP: ___________________________________________________________

To set my digital watch to 5:30 P.M., I don't wrap it up and mail it off to Casio. I push a button!

To display the time on my watch, I don't wrap it up and mail

it off to Casio and have them tell me what time it is. I have it

display the time itself, perhaps pushing a button to turn on the

backlight so I can see it .

(19)

19

Notes:

1. Member functions: "Inside" an object, so don't pass object to them as a parameter. (They receive the object to be operated implicitly, rather than explicitly via a parameter.)

Non-member functions: "Outside" an object, so to operate on an object, they must receive it via a parameter.

2. Public items must be qualified when referred to outside the class declaration:

ClassName::ItemName

Public constants are usually declared ____________ so they are global class properties that can be accessed by all objects of that class type rather than each object having its own copy.

3. Simple member functions: Usually specified as _______________ functions — suggests to compiler to replace a function call with

______________________

________________________________________________________________

(20)

Two ways to inline a class function member:

1. Prototype in class declaration;____________________________

____________________________________________________

qualifying the name as usual.

In ClassName.h:

class ClassName {

public:

RetType SimpleFun(param_list); //prototype . . .

};

__________ RetType

ClassName::SimpleFun(param_list) { . . . } // definition

2.Put function’s (instead of prototype)

(21)

Class Invariant: A condition (boolean expression) that ensures that the __________________________________________

Example: 1 < myHours < 12 && 0 < myMinutes < 59 &&

myAMorPM == 'A' or 'P' && 0 < myMilTime < 2359

Then other operations can be sure data members have valid values.

How?

1. Use an if statement — see Set()

2. Use __________ (class_invar) (must #include <cassert> ) continue execution halt execution and display error message

true false

(22)

3._________________that the calling function can and take appropriate action:

//--- Function to implement the Set operation ---

void Time::Set(unsigned hours, unsigned minutes, char am_pm) {

// Check class invariant

if (hours >= 1 && hours <= 12 &&

minutes >= 0 && minutes <= 59 &&

(am_pm == 'A' ||am_pm == 'P')) {

. . . }

else {

char error[] = "*** Illegal initializer values ***\n";

___________________________

(23)

To catch this exception, a calling function might contain:

________

{

mealTime.Set(13, 30, 'P');

cout << "This is a valid time\n";

}

__________________________________

{

cerr << "ERROR: " << badTime << endl;

exit(-1);

}

cout << "Proceeding. . .\n";

When executed, the output produced will be

ERROR: * Illegal initializer values *

(24)

Class Constructors

Constructing an object consists of:

(1) _______ for the object, and (2) the object.

In our example, after the declaration Time mealTime;

memory has been allocated for object mealTime and it's data members have some default (perhaps "garbage") initial values.

Need to:



Specify initial values for mealTime



Provide default values to be used if no initial values are

specified.

(25)

Class Constructors - Properties

1. Names are always the same as the class name.

2. Initialize the data members of an object with default values or with values provided as arguments.

3. Do not return a value; have no return type (not even void).

4. Often simple and can be inlined.

5. Called _________________________________.

6. If no constructor is given in the class, ______________________

_____________________________which allocates memory and initializes it with some default (possibly garbage) value.

A default constructor is one that is used ____________________

____________________________________________________:

ClassName object_name;

7. If we supply a class constructor, we must also provide_________

(26)

Constructors for Time class

In Time.h class Time { public:

/* --- Construct a class object (default).

* Precondition: A Time object has been declared.

* Postcondition: Data members initialized to 12, 0, 'A', and 0.

****************************************************************/

_____________________

/* --- Construct a class object (explicit values).

* Precondition: A Time object has been declared.

* Receive: Initial values initHours, initMinutes,and * initAMPM

* Postcondition: Data members initialized to initHours,initMinutes, * initAMPM, & correspoding military time

**********************************************************/

__________________________________________ _____________________ ___________________

. . .

// other member function prototypes private:

(27)

Constructors for Time class - Implementation

In Time.h, after class declaration:

In Time.cpp:

_______________(unsigned initHours, unsigned initMinutes, char initAMPM) {

// Check class invariant

assert(initHours >= 1 && initHours <= 12 &&

initMinutes >= 0 && initMinutes <= 59 &&

(initAMPM == 'A' || initAMPM == 'P'));

myHours = _________________;

myMinutes = _______________;

myAMorPM = ________________;

(28)

Testing #1:

Time ______________________________, //default constructor

______________________________; //explicit-value constructor

Create and initialize 2 Time objects:

mealTime.Display(cout);

cout << endl;

Execution:

mealTime myHours

myMinutes myAMorPM myMilTime

Function members Default Constructor

bedTime myHours

myMinutes myAMorPM myMilTime

Function members

Explicit Value Constructor

(29)

Constructors for Time class — Default Arguments

Can combine both constructors into a single constructor function by using _______________________:

Replace constructors in Time.h with:

/*--- Construct a class object.

Precondition: A Time object has been declared.

Receive: Initial values initHours, initMinutes, and initAMPM (defaults 12, 0, 'A')

Postcondition: Data members initialized to initHours, initMinutes, initAMPM, & correspoding military time.

*/

Note: Any parameter with default argument must appear after all

(30)

Testing:

Time mealTime, t1(5), t2(5, 30), t3(5, 30, 'P');

Creates 4 Time objects:

mealTime.Display(cout);

cout << endl;

t1.Display(cout); cout << endl;

t2.Display(cout); cout << endl;

Execution:

12:00 A.M. (0 mil. time) 5:00 A.M. (500 mil. time) 5:30 A.M. (530 mil. time)

(31)

Copy Operations

Two default copy operations are provided:

1. Copy in __ (via _) 2. Copy in (via _______________)

Each makes a _______________________________ allocated to

the data members of the object.

(32)

Examples:

Both:

1. Allocate memory for t

2. Copy data members of bedTime so t is a copy of bedTime

In contrast ^:

Time t = _________________________

calls the _________________________ to construct a (temporary)

Time object and then copies it into t ^. _{What about}

(33)

There is a default copy operation for assignment.

Example ^:

t = mealTime;

copies the members of mealTime into t , replacing any previous values:

120 A 0

It returns __________________________________________

(34)

Access Member Functions

Data members are private: they cannot be accessed outside the class. To make the values stored in some or all of these members accessible, provide____________(or extractor) member functions

Example:

To provide access to myHours of class Time.

(Access for the remaining members is analogous.)

 simply retrieves and returns the value stored in a data member

 inline, because it's simple

 prototype (and define) as a const function Add in Time class declaration

/* Hour Accessor

* Return: value stored in myHours data member of * Time object containing this function */

(35)

Add below Time class declaration

inline unsigned Time::Hour() const {______________________}

Testing:

Time mealTime;

. . .

cout << "Hour: " << mealTime.Hour() << endl;

Execution:

Hour: 12

(36)

Output and Input

Add output operation(s) to a class early so it can be used for debugging other operations.

Example: overload operator<< for a Time object Instead of:

cout << "We'll be eating at " ; _______________________________________

cout << endl;

we can write:

cout << "We'll be eating at "

_______________________________________

(37)

Overloading operators

In C++, operator  can be implemented with the function ___________________.

If a member function of a class C, and a is of type C, the compiler treats a  b as

_________________________

If not a member function of a class C, the compiler treats a  b as

_________________________

(38)

Overloading Output Operator <<

Can operator<<() be a member function?

______, because the compiler will treat

cout << t

as

________________________

which means that operator<<(const Time &) would have to be a ________________________________________________

and we can't (or don't want to) modify standard C++ classes.

Putting the prototype

ostream& operator<<(ostream & out, const Time& t);

inside our class declaration producs a compiler error like:

(39)

Why is out a reference parameter?

So _________________________________________________

when out does.

Why is t a const reference parameter?

Avoid ______________________________________________

Why is return type ostream & (a reference to an ostream)?

Else a __________________ is returned.

Why return out?

So we can __________________________.

Since << is ________-associative:

cout << t1 << endl << t2 << endl;

 ____________________ << endl << t2 << endl;

 first function must return _________

 _______ << endl << t2 << endl;

 ____________________ << t2 << endl;

(40)

Method 1: Put definition in .h file, after class declaration, and

have it __________________________________________.

Inline it, because it's simple.

. . .

} // end of class declaration . . .

**/* operator<< displays time in standard and military format.**

Receive: ostream out and Time object t

Output: time represented by Time object t Pass back: ostream out with t inserted into it Return: out

*/

inline ostream & operator<<(ostream & out, const Time & t) {

Overloading << for a Class

(41)

Method 2: Define operator<<() outside the class declaration as a _______________ function and:

(i) use _______ to display data members, or (ii) declare it to be a in the class declaration.

In class declaration

/* doc. as before */

_________

ostream & operator<<(ostream & out, const Time & t);

Outside class declaration (in .cpp file)

ostream & operator<<(ostream & out, const Time & t)

{

out << t.myHours << ':'

<< (t.myMinutes < 10 ? "0" : "") << t.myMinutes

<< ' ' << t.myAMorPM << ".M. ("

<< t.myMilTime << " mil. time)";

return out;

(42)

Friend Functions

A function that a class declares as a friend is a

_______________ function to which the class has granted

permission to ________________________________________.

Note: Because a friend function is not a function member:

 Don't ____________________________ with class name and scope operator (::).

 Don't put ____________ in definition.

 It receives the object on which it operates as a parameter.

 It uses the dot operator to access the data members.

(43)

To add an input operator to our Time class, we proceed in much the same way as for output. We could either:

1. Add a member function ReadTime() that reads values and stores them in the data members of a Time object; then call it from non- member function operator>>().

2. Declare operator>>() to be a friend function so that it can

access the data members of a Time object and store input values in them.

Is one of twotwo methods for input/output preferred?

We'll see later when we study inheritance and polymorphism that the

first method is preferred (or perhaps required).

(44)

Relational Operators (<)

Specification:

Receives: Two Time objects

Returns: True if the first object is less than the second; false otherwise.

Should operator<() be a member function?

Internal perspective: I compare myself with another Time object and determine if I am less than that other object

External perspective: Two Time objects are compared by an external function to determine if the first is less than the second.

OOP: "I-can-do-it-myself" principle ( objects self-contained):

Use member functions whenever possible.

Rephrased specification:

Receives: A Time object (and the current object implicitly)

(45)

// Internal perspective : Add to Time.h

class Time {

public: // member functions ...

/***** Relational operators *****/

/* operator< determines if one Time is less than another Time * Receive: A Time t (and the current object implicitly)

* Return: True if time represented by current object is < t.

*/ ____________________________________;

...

}; // end of class declaration

(46)

Caveat re Operator Overloading

Internal perspective may lead to seeming inconsistencies:

Example: Suppose a and b are objects of type class C.

a < b okay?

Yes, equivalent to _________________________

b < a okay?

Yes, equivalent to _________________________

a < 2 okay?

_, if there is a _______, since this is then equivalent to _

2 < a okay?

, equivalent to _______________which is meaningless.

(47)

Overloaded Operator as Friend

External perspective: (Permits a < 2 and 2 < a , if 2 can be promoted) class Time

{

public: // member functions ...

**/* operator<**

* Receive: Two Times t1 and t2

* Return: True if time t1 is less than time t2/

*/

___________________________________________________________________

);

...

}; // end of class declaration inline bool

Time::

operator<

(const Time& t1, const Time& t2)

(48)

Adding Increment/Decrement Operators

Specification:

Receives: A Time object (perhaps implicitly)

Returns: The Time object with minutes incremented by 1 minute.

Question: Should it be a member function? _________

Add to Time.h:

/* Increment operator */

**/* --- Advance() increments a Time by 1 minute.**

Postcondition: The Time object has its minutes incremented by 1.

**---*/**

(49)

Add to Time.cpp:

//--- Function to implement Advance() --- void Time::Advance()

{

myMinutes++;

myHours += myMinutes / 60;

myMinutes %= 60; myHours %= 12;

if (myMilTime == 1159) myAMorPM = 'P';

else if (myMilTime == 2359) myAMorPM = 'A';

// else no change myMilTime =

ToMilitary(myHours, myMinutes, myAMorPM);

(50)

We could replace Advance() with overloaded operator++().

Question: How do we distinguish between prefix ++ and postfix ++?

++

Postfix +

+:

Solution: In C++, when the

Compiler encounters: It looks for:

Prefix ++:

(51)

Redundant Declarations

Class Time might be used in different programs, libraries, etc., so it could be included several times in the same file

e.g.,

Program needs Time class, so it #includes "Time.h"

Program also needs library Lib, so it #includes "Lib.h"

. . . but Lib.h also #includes "Time.h"

This can cause "redeclaration" errors during compiling.

How do we prevent the declarations in Time.h from being included

more than once in a file?

(52)

Conditional Compilation

Wrap the declarations in Time.h inside preprocessor directives.

(Preprocessor scans through file removing comments, #including files, and processing other directives (which begin with #) before the file is passed to the compiler.)

3. More about Data Structures and ADTs: C++ data types