bahan kuliah AORKOM

1. Abstract Data Types (ADT)
and C++ Classes
1-15-2013

2.  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

3.  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.

4.  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

5. 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

6. 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”)

7. 1. Easier to understand; little redundant code.
2. Facilitates software reuse.
3. Easier to implement.
4. Easier to test.
5. Easier to modify.

8.  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.

9.  Class designer/implementer
- designs & implements a class
vs.
 Client programmer
- uses a class for an application
vs.
 End-user
- uses the application

10.  Procedural Abstraction (Algorithm)
 Data Abstraction (Data)

11.  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

12.  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”

13. Circle
constructor(s): Circle(int,int),
Circle(float,int,int);
float computeArea();
float getRadius();
void setRadius(float);
// etc.
Type
name
Public
interface

14.  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

15.  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

16.  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.

17. private instance variables:
private float radius;
private Point center;
public methods:
constructor(s)
accessor methods (get)
mutator methods (set)
float computeArea()
… etc.

18. 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.

19.  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

20. Point
constructor(s): Point(int,int),
Point(); // default (0,0)
int getX();
int getY();
// etc.
Type
name
Public
interface

21. private instance variables:
private int xCoordinate
private int yCoordinate
public methods:
constructor(s)
accessor methods (get)
mutator methods (set)
… etc.

22.  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.

23.  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;
}

24.  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;
}

25. 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();
messagereceiver
(this)
call the method
Point::getX()
class of the
receiver
no args

26.  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

27. 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));
}

28. 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”;

29. 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;
messagereceiver
(this)
problem:
The receiver is type ostream
arg
solution:
Make this function a “friend”

30. 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

31.  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.

32. 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 */

33. 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!

34. 1. Point.h header file (declarations & inline
code)
2. Point.cpp implementation file (code)
3. main.cpp test driver
g++ *.cpp

35. % 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

36.  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