Object-Oriented Programming (Part 2)

Programming Language ConceptsLecture 19

Prepared byManuel E. Bermúdez, Ph.D.

Associate ProfessorUniversity of Florida

Object-Oriented Programming(Part 2)

The this Pointer

• To invoke a class member function, use the ''dot'' operator (structure field selection):

<object name> . <member function name>

• The this pointer: an implicit parameter to each class member function, of type (Object *).

• Its value is the address of the “current” object, through which the member function has been invoked.

• It can be used inside member functions. Examples coming up.

The const Qualifier

Three places where the const qualifier can be usedin a member function declaration:

class A { ... const X& f(const Y& y) const { // 1. Can't assign to object returned // 2. Can't change parameter y // 3. Can't change this. }}

The const Qualifier (cont’d)

A a;

...

a.f(y)

// f is a member of class A.

// a is an object of class A.

// a.f(y) can't be assigned a value.

// a.f(y) cannot change y.

// a.f(y) cannot change a.

Constructors

class cell {cell(int i, cell *n) {info=i;

next=n;}int info;cell *next;

};

cell a(1,0); //declare a and call cell(1,0)

cell b(2,&a);//declare b and call cell(2,&a)

• These don’t just declare a and b of type cell.• They also call the constructor function cell.

Overloading Constructors

class cell {

cell (int i) {info=i; next=this;}

cell (int i, cell *n) {

info=i; next=n;

}

int info;

cell *next;

};

cell c(7);

Friend Classes and Information Hiding

• Class members are private by default.• A friend declaration in a class allows functions

from another class to access members of the current one.

class cell {friend class circlist;

cell (int i) {info=i; next=this;}cell (int i, cell *n) {info=i;

next=n;}int info;cell *next;

};

• cell has no public interface. It’s an 'auxiliary' data type, solely for use with circlist.

Friend Classes and Information Hiding

class circlist {private:

cell *rear;public:

circlist() {rear=new cell(0);}~circlist();int empty() const {return rear==rear->next;}int top() const {return rear->next->info; }void push (int);int pop();void enter(int);

};

The class circlist has a total of seven memberfunctions, four of which still need to be defined.

Friend Classes and Information Hiding

circlist::~circlist(){cell *tmp1=rear, *tmp2=rear->next;while (tmp2!=rear) { delete tmp1; tmp1=tmp2; tmp2=tmp1->next;};delete tmp1;

}void circlist::push(int x) {rear->next = new cell (x, rear->next);

}

Friend Classes and Information Hidingvoid circlist::enter(int x) {

rear->info = x;

rear = rear->next = new cell(0,rear->next);

}

int circlist::pop() {

if ( empty() ) return 0;

cell *front = rear->next;

rear->next = front->next;

int x = front->info;

delete front; return x;

}

Friend Classes and Information Hiding

• Class circlist hides its internal details.

• Objects of type circlist are manipulated exclusively through the public interface of circlist.

• Information hidden inside circlist: circlist based on cell, only rear is stored.

• Should the implementation of circlist ever change, users of circlist will be COMPLETELY UNAFFECTED.

Three principles of Object-Oriented Programming:Abstraction, Encapsulation, Information Hiding.

Derived Classes

Humans tend to abstract on two dimensions:

• A part-of B, (a.k.a. has_a)• A kind-of B, (a.k.a. is_a).

ADT programming focuses on the has_a relation.

OOP also includes the is_a abstraction.

Support for the is_a abstraction implies:

if A is_a B, and B has_a X, then A has_a X.

This is inheritance !!

Derived Classes (cont’d)

In general,

class <derived-class> : public <base-class> {<member-declarations>

}

• All members of <base-class> are also members of <derived-class>.

• The <derived-class> may have additional members.

• public clause: derived members retain their attributes (public, private, or protected).

• private clause: derived members will be private.

The circlist class, revisited

class circlist {public:

int empty () const { return rear==rear->next;}int top() const { return rear->next->info; } // 'inspectors'

protected:circlist () {rear = new cell(0);};~circlist();void push(int);int pop();void enter(int); // 'mutators'

private:cell *rear;

}

The circlist class, revisited

• Protected members behave as if they were private, except that:– they are visible to members (and friends) of

derived classes.

• Some of the circlist functions are now protected so they'll be inherited by the new class queue.

Derived class queue

class queue: private circlist {

public:

queue() { }

~queue() { }

void enqueue (int x) { enter(x); }

int dequeue () { return pop(); }

circlist::empty;

circlist::top;

};

Complete list of members of queue

Public Functions:queue new constructor~queue new destructorenqueue newdequeue new

empty, top inherited, explicitly made public

Private Functions:push inheritedpop inheritedenter inherited

Private Variables (accessible to new functions of queue):none

Private Variables (accessible only by inherited functions):rear inherited

Another class derived from circlist

class stack: private circlist {

public:

stack () { }

~stack () { }

void push (int x) { circlist::push(x); }

int pop() { return circlist::pop(); }

circlist::empty;

circlist::top;

};

Sample Use of these Classesmain () {

stack s;queue q;s.push(1); s.push(2); s.push(3);q.enqueue(7); q.enqueue(8); q.enqueue(9);cout << "Stack Top: " << s.top() << endl;cout << "Queue Top: " << q.top() << endl;cout << s.pop() << " ";cout << s.pop() << " ";cout << s.pop() << endl;cout << q.dequeue() << " ";cout << q.dequeue() << " ";cout << q.dequeue() << endl;

}

Results:

Stack Top: 3Queue Top: 73 2 17 8 9

Class Hierarchies

class employee { /* . . . */ };class manager:

public employee { /* . . . */ };class director:

public manager { /* . . . */ };class temporary { /* . . . */ };class secretary:

public employee { { /* . . . */ };class tsec:

public temporary, //MULTIPLE INHERITANCE !!public secretary { /* . . . */ };

class consultant:public temporary,public manager { /* . . . */ };

Class Hierarchy is a DAG

Type Identification

In our example, given a pointer of type employee*, it can point to:employee, secretary, tsec, manager, or director.

Three solutions, in general, to this problem:1.Only use pointers to classes that have no

derived classes. Sure ...2.Use a variable to determine the type of the

object. Very easy to forget to check the type variable.

3.Use virtual functions.

Virtual Functions

Allow print in both employee and manager, with differentdefinitions. C++ will “do the right thing”, based on the actualobject class.

Virtual Functions (cont’d)

Virtual Functions (cont’d)

Virtual Functions (cont’d)

Operator Overloading

• Allow intrinsic operators in C++ to be applied to objects of new types.

• Overloading is achieved by defining functions named operatorXXX, where XXX is one of:

• Can’t overload these:

• Can’t change precedence, arity or associativity. Can’t add new operators, either.

Operator Overloading (cont’d)

Example: the subscript operator, which returnsa reference. First, without operator overloading:

Operator Overloading (cont’d)

• Now, simply replace elem with operator[]:

Overloading Operators << and >>

• We wish to use << and >> for user-defined objects, the same way they are (normally) used for "built-in" objects (e.g. int, char, etc.).

Overloading Operators << and >>

• Input is similar. The signature is:

• To use them:

The Orthodox Canonical Form

An idiom (pattern). The OCF is characterizedby the presence of:

• A default constructor:X::X()

• A copy constructor:X::X(const X&)

• An assignment operator:X& operator=(const X&)

• A destructor:X::~X()

Programming Language ConceptsLecture 19

Prepared byManuel E. Bermúdez, Ph.D.

Associate ProfessorUniversity of Florida

Object-Oriented Programming (Part 2)