Abstract Data Types (ADT)

and C++ Classes

1-15-2013

Abstract Data Types (ADT) & UML

C++ Class definition & implementation

constructors, accessors & modifiers

overloading operators

friend functions

HW#1 posted – due: Tuesday, 1/22

Quiz Thursday, 1/24

FAQ 5.14 What is an abstraction and why is it important?

FAQ 5.15 Should abstractions be user-centric or

developer-centric?

An abstraction is a simplified vew of an object

in the user’s own vocabulary. In OO and C++,

an abstraction is the simplest interface to an

object that provides all the features and

services the intended users expect.

User-centric. Focus on the user’s point of view.

Computes what each employee should be paid for a day of work. Reads a file containing start and stop times for each employee. Then calculates and saves the pay amounts to another file.

int runPayCalculator (const char csInputFileName[], const char csOutputFileName[])

Sample input:

510 + 24601

990 - 24601

Sample output

24601 96

int runPayCalculator (const char csInputFileName[], const char csOutputFileName[])

Algorithm:

call computeHours and then computeAndWritePay

Data structure:

The number of hours worked by each employee is stored in an array indexed by the possible employee numbers. This array is of size MAX_EMPLOYEE_NUMBER + 1, where MAX_EMPLOYEE_NUMBER is a global constant

In a well-designed modular program, software components should satisfy the following two properties:

1. Each component performs one well-defined task. (i.e. “cohesion”)

2. Each component is as independent as possible from the others. (i.e. loosely coupled”)

1. Easier to understand; little redundant code.

2. Facilitates software reuse.

3. Easier to implement.

4. Easier to test.

5. Easier to modify.

Independence of modules is typically achieved by “information hiding” (which can be achieved by “encapsulation”).

Procedural Abstraction

Use of a function depends on its purpose (what it does) but not on its implementation (how it does it).

FAQ 5.18 What’s the value of separating interface from implementation?

It’s a key to eliminating the ripple effect when a

change is made.

Class designer/implementer

- designs & implements a class

vs.

Client programmer

- uses a class for an application

vs.

End-user

- uses the application

Procedural Abstraction (Algorithm)

Data Abstraction (Data)

An Abstract Data Type (ADT) is a specification of a set of data and a set of operations that can be performed on the data.

examples:

String Circle

List Dice

Dictionary Song

Student Telephone Directory

Time Complex number

In C++, a class represents an ADT.

An “instance” of a class is a specific object which is created, and the data members are filled in with values (possibly default values). Objects are created with a specialized member function called a “constructor”.

An instance of a class is destroyed (recycled) with a specialized member function called a “destructor”

Circle

constructor(s): Circle(int,int),

Circle(float,int,int);

float computeArea();

float getRadius();

void setRadius(float);

// etc.

Type name

Public

interface

An ADT is a contract between

The interface designer and ...

The coder of a class that implements the interface

Precondition: any assumption/constraint on the method data before the method begins execution

Postcondition: describes result of executing the method

A C++ program is a collection of functions and classes.

A class represents a set of objects that have common properties.

A class is a template for creating objects.

A class represents a type.

Type determines the set of values an object may have.

Type determines the operations that can be performed on those values.

In C++ there are two kinds of types:

Primitive or build-in types

User Defined or class types

A class consists of members

Data members – also called data fields or attributes

Member functions – also called operators, functions or methods

Data members are also sometimes called instance variables because each object (instance of a class) contains them.

Data members may be either primitive or class types.

private instance variables:

private float radius;

private Point center;

public methods:

constructor(s)

accessor methods (get)

mutator methods (set)

float computeArea()

… etc.

Represent a 2D “point”

Data: (x , y) coordinates, integer values

Methods:

create a point with coordinates (0,0)

create a point with coordinates (x,y),

get the x coordinate of a point,

get the y coordinate of a point,

draw a point

erase a point

move a point

etc.

Unified Modeling Language (UML) is a standard diagram notation for describing a class

Instance

of Person

Field

values

Class

name

Field

signatures:

type and name

Method signatures:

name, argument

types, result type

Point

constructor(s): Point(int,int),

Point(); // default (0,0)

int getX();

int getY();

// etc.

Type name

Public

interface

private instance variables:

private int xCoordinate

private int yCoordinate

public methods:

constructor(s)

accessor methods (get)

mutator methods (set)

… etc.

Class members that are declared in the public section of a class definition are accessible to all functions (inside or outside) the class.

Class members that are declared in the private section of a class definition are accessible only to functions that are members of the class.

Generally we want the operators (member functions) visible to the users of the class.

Thus they are declared public.

Generally we want to keep the implementation details (data members) hidden from the users of the class

Thus they are declared private.

A constructor is a member function that initializes the data members of an object when the object is created.

Note the use of

initialization lists

(more efficient than

assignment

statements)

class Point { public: Point(int i, int j) : x(i), y(j) { } Point() : x(0), y(0) { } private: int x; int y; }

A modifier function provides the ability to modify the value of a private data member

void setX(int newX) {

x = newX;

}

An accessor function provides the ability to read the value of a private data member, without changing it (note use of “const”)

int getX() const { return x; }

class Point {

public:

Point(int i, int j) :

x(i), y(j) { }

Point() :

x(0), y(0) { }

int getX() const

{ return x; }

private:

int x;

int y;

}

Client programmer can write:

Point p1(10,30);

Point p2;

int i = p1.getX();

message receiver

(this)

call the method Point::getX()

class of the receiver

no args

A member function definition (implementation) may be included in the class definition.

The compiler can insert the code for the function body where the function is called.

This is known as an inline function.

Use of inline member function is recommended only for the following:

Functions whose body is very small (one or two lines)

● Constructors

● Accessors

● Modifiers

How would you compare two points, p1 and p2.

Define a method to compare their x and y coordinates.p

p1.lessThan(p2)

Overload the operator <

p1 < p2

bool Point::operator< (const Point& other) const { return (x < other.x) || ((x == other.x) && (y < other.y)); }

class Point {

public:

Point(int i, int j) :

x(i), y(j) { }

Point() :

x(0), y(0) { }

int getX() const

{ return x; }

bool operator<(const Point& other) const;

private:

int x;

int y;

}

bool Point::operator<

(const Point& other) const { return // you fill in...

}

Client programmer can write:

Point p1;

cin>>i; cin>>j;

Point p2(i,j);

if (p2 < p1) then cout << “lol”;

class Point {

public:

// other methods as before

std::ostream& operator<<(

std::ostream& os,

const Point& p);

private: // as before

}

ostream& operator<<(

ostream& os,

const Point& p) {

os << //... you fill in

return os;

}

Point p1(10,30);

cout << p1;

message receiver

(this)

problem: The receiver is type ostream

arg

solution: Make this function a “friend”

class Point {

public:

// other methods as before

friend std::ostream&

operator<<(

std::ostream& os,

const Point& p);

private: // as before

}

ostream& operator<<(

ostream& os,

const Point& p) {

os << //... you fill in

return os;

}

Point p1 =

new Point(10,30);

cout << p1;

solution: Make this function a “friend” Gives permission for this function to have complete access to the data members, even though they are private to the class

A friend is an external function or class that is given the same access to the members of a class as if it were a member.

We declare the ostream insertion operator to be a friend

So it can access the data members and insert their string representation into the output stream.

Because this operator’s left-hand operand is an ostream object, thus it cannot be defined as a member of the Point class.

class Point {

public:

// other methods as before

friend std::ostream&

operator<<(

std::ostream& os,

const Point& p);

private: // as before

}

ostream& operator<<(

ostream& os,

const Point& p) {

os << //... you fill in

return os;

}

/* how do these differ? */

Point p1 = new Point(10,30);

Point p2(10,30);

/* how do these differ? */

cout << p1.getX() << endl;

cout << p1;

/* additional examples were

done in class */

class Point {

public:

// other methods as before

bool operator==(const

Point& other) const;

private: // as before

}

bool Point::operator==

(const Point& other) const

{ return // you fill in...

}

Point p3 =

new Point(10,30);

if (p2 == p3)

cout << “equal

points” << endl;

Now that we have implemented operators == and <,

what about <= ?

Reuse code!

1. Point.h header file (declarations & inline code)

2. Point.cpp implementation file (code)

3. main.cpp test driver

g++ *.cpp

% g++ -c *.cpp

% g++ *.o –o testPt

testPt: main.o Point.o

g++ main.o Point.o –o testPt

main.o: main.cpp Point.h Point.o

g++ -c main.cpp –o main.o

Point.o: Point.h Point.cpp

g++ -c Point.cpp –o Point.o

clean:

rm –f *.o testPoint

Makefile Could type this:

or

% make

% ./testPt

% make clean

For Thursday, read Chapter 2, sections 2.6 – 2.9 of Maciel & Chapter 3, section 3.1

Be prepared to write a simple class definition for Circle

Quiz #1 next week, Thursday, 1/24, in class