object-oriented programming (part 2)
DESCRIPTION
Object-Oriented Programming (Part 2). Programming Language Concepts Lecture 19. Prepared by Manuel E. Bermúdez, Ph.D. Associate Professor University of Florida. The this Pointer. To invoke a class member function, use the ''dot'' operator (structure field selection): - PowerPoint PPT PresentationTRANSCRIPT
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)