lab2

Download
Share  Add to  Flag Embed
Uploaded from authorPOINTLite
Views:
 
Category: Entertainment
     
 
License:   All Rights Reserved

Presentation Description

No description available.

Comments

Presentation Transcript

Lab 2: Polymorphism: 

Lab 2: Polymorphism One Name, Many Purposes Two forms: Function Overloading Operator Overloading

Function Overloading: 

Function Overloading Two or more functions can share the same name provided that: Type of their arguments differs OR Number of their arguments differs To overload a function, simply declare and define all required versions.

Exampe: abs(): 

Exampe: abs() int abs(int n) {return n < 0 ? –n : n;} long abs(long n) {return n < 0 ? –n : n;} double abs(double n) {return n < 0 ? –n : n;} int main() { cout<<“Abs. value of –10:” << abs(-10) << “\n”; cout<<“Abs. value of –10L:” << abs(-10L) <<“\n”; cout<<“Abs. value of –10.1:” << abs(-10.1) <<“\n”; return 0; }

Operator Overloading: 

Operator Overloading Operator overloading is just a type of function overloading. An operator is always overloaded relative to a user-defined type, such as a class. To overload an operator, you create an operator function.

Member Operator function: 

Member Operator function An operator function is often a member of the class for which it is defined. Syntax: return-type class-name::operator#(arg-list) { // operation to be performed }

Binary Operator: 

Binary Operator When a member operator function overloads a binary operator, the function will have only one parameter. Consider: x + y x: object that generates the call to the operator function y: parameter of the operator function

Example: coord class: 

Example: coord class class coord { int x, y; // coordinate values public: // Constructor function is overloaded coord() {x = 0; y = 0;} coord(int i, int j) {x = i; y = j;} coord operator+(coord ob2); }

Example: operator+(): 

Example: operator+() // Overload + relative to coord class coord coord::operator+(coord ob2) { coord temp; temp.x = x + ob2.x; temp.y = y + ob2.y; return temp; }

Example: overloaded +: 

Example: overloaded + int main() { coord o1(10,10), o2(5,3), o3, o4; o3 = o1 + o2; // a string of additions is allowed. o4 = o1 + o2 + o3; return 0; }

Example: coord class: 

Example: coord class class coord { int x, y; // coordinate values public: coord() {x = 0; y = 0;} coord(int i, int j) {x = i; y = j;} coord operator+(coord ob2); coord operator– (coord ob2); coord operator=(coord ob2); }

Overloading – and =: 

Overloading – and = The operator –() can be implemented similarly to operator+(), and we omit the details. We focus on the assignment operator function, operator=().

Example: operator=(): 

Example: operator=() void coord::operator=(coord ob2) { x = ob2.x; y = ob2.y; } int main() { coord o1(4,6), o2; o2 = o1; return 0; }

Assignment Operator: 

Assignment Operator In C++, the following type of statement is syntactically correct: a = b = c = d = 0; However, in our example, the following statement is invalid (why?): o3 = o2 = o1; How to modify our program so as to support the above statement?

Introducing this pointer: 

Introducing this pointer this is a pointer: automatically passed to any member function when it is called. pointing to the object that generates the call. For example, consider: ob.f1(); // assume ob is an object f1() is automatically passed a pointer to ob. This pointer is referred to as this.

Example: operator=(): 

Example: operator=() coord coord::operator=(coord ob2) { x = ob2.x; y = ob2.y; return *this; // return the object } int main() { coord o1(4,6), o2, o3; o3 = o2 = o1; // this statement is now valid return 0; }

Overload + for (object + integer): 

Overload + for (object + integer) Suppose you want to overload operator+() so that you can add an integer value to a coord object. For example, use the statement o1 + 3 to represent o1.x + 3 and o1.y + 3

Example: coord class: 

Example: coord class class coord { int x, y; // coordinate values public: coord() {x = 0; y = 0;} coord(int i, int j) {x = i; y = j;} coord operator+(coord ob2); coord operator+ (int i); }

Overload + for (object + integer): 

Overload + for (object + integer) coord::operator+(int i) { coord temp; temp.x = x + i; temp.y = y + i; return temp; }

How about integer + object?: 

How about integer + object? What happens when the compiler sees the following statement? o3 = 19 + o1; This statement generates a compile-time error. How to solve this problem?

Introducing Friend Functions: 

Introducing Friend Functions A friend is NOT a member of a class but still has access to its private elements. Situations when friend functions are useful: Operator overloading Creation of certain types of I/O functions One function has to access the private members of two or more different classes.

Example: friend function: 

Example: friend function class myclass { int n, d; public: myclass(int i, int j) {n = i; d = j;} //declare a friend of myclass friend int isfactor(myclass ob); }

Example: friend function: 

Example: friend function /* This function returns true if d is a factor of n. Notice that the keyword friend is not used in the definition of isfactor(). */ int isfactor (myclass ob) { if (! (ob.n % ob.d)) return 1; else return 0; }

Example: friend function : 

Example: friend function int main() { myclass ob1(10,2); if (isfactor(ob1)) cout << “2 is a factor of 10\n”; return 0; }

Friend Function: 

Friend Function It is important to understand that a friend function is NOT a member of the class. For example, // wrong; isfactor() is not a member function ob1.isfactor() Friends are called just like regular functions.

integer + object (revisited) : 

integer + object (revisited) class coord { int x, y; // coordinate values public: coord() {x = 0; y = 0;} coord(int i, int j) {x = i; y = j;} friend coord operator+(coord ob1, coord ob2); friend coord operator+(coord ob1, int i); friend coord operator+(int i, coord ob1); }

Overload for integer + object: 

Overload for integer + object coord operator+ (int i, coord ob1) { coord temp; // private variables of ob1 can be accessed temp.x = ob1.x + i; temp.y = ob1.y + i; return temp; }

C++ I/O Basics: 

C++ I/O Basics C++ I/O system operates through streams, e.g. cin, cout, …etc. The ios class contains many member functions and variables that control the operation of a stream. Each C++ stream has associated with it a number of format flags that determine how data is displayed.

Some Format Flags: 

Some Format Flags enum { skipws = 0x0001; : dec = 0x0010, oct = 0x0020, hex = 0x0040, : };

Formatted I/O: Hexadecimal: 

Formatted I/O: Hexadecimal Using setf() and unsetf() to set and unset a flag. Example: cout.unsetf(ios::dec); cout.setf(ios::hex); cout << 10; In the above example, “a” will be displayed, which is the hexadecimal representation of 10.

width() and fill(): 

width() and fill() A minimum field width can be specified by using the width() function. Example: cout.width(10); cout << “hello” << “\n”; cout.fill(‘%’); cout.width(10); cout << “hello” << “\n”;

width() and fill() (cont’d): 

width() and fill() (cont’d) The program displays the following output: hello %%%%%hello

Overload Insertion Operator: 

Overload Insertion Operator In C++, the output operation is called an insertion and the << is called the insertion operator. In the next example, you’ll learn how to overload C++’s insertion operator <<.

Example: Overload <<: 

Example: Overload << class coord { int x, y; // coordinate values public: coord() {x = 0; y = 0;} coord(int i, int j) {x = i; y = j;} friend ostream &operator << (ostream &out, coord ob); }

Example: Overload <<: 

Example: Overload << ostream &operator<<(ostream &out, coord ob) { out << ob.x << “, ” << ob.y << ‘\n’; return out; }

Example: Overload <<: 

Example: Overload << int main() { coord a(1,1); cout << a; return 0; } This program displays the following: 1, 1