CHAPTER 15 OVERLOADING AND TEMPLATES. In this chapter, you will: Learn about overloading Become...

CHAPTER 15

OVERLOADING AND TEMPLATES

In this chapter, you will: Learn about overloading Become aware of the restrictions on operator

overloading Examine the pointer this Learn about friend functions Explore the members and nonmembers of a

class Discover how to overload various operators Learn about templates Explore how to construct function templates

and class templates

• The capability of combining data and operations on data is called encapsulation. This is the first principle of OOD.

• In Chapter 12, we also defined abstract data type (ADT) and discussed how classes in C++ implement ADT.

• In Chapter 13, we discussed how new classes could be derived from existing classes through the mechanism of inheritance and composition.

• Inheritance is the second principle of OOD, as defined in Chapter 13, and encourages code reuse.

WHY OPERATOR OVERLOADING IS NEEDED

• Recall the class clockType as defined in Chapter 12.

• Consider the following statements.

clockType myClock(8,23,34);

clockType yourClock(4,5,30);

myClock.printTime();

myClock.incrementSeconds();

if(myClock.equalTime(yourClock))

.

.

.

• We would like to use the following statements in place of the above statements.

cout<<myClock;

myClock++;

if(myClock == yourClock)

.

.

.

• The only built-in operations on classes are the assignment operator and the member selection operator.

• Therefore, other operators cannot be applied, directly, on class objects.

• C++ allows the programmer to extend the definitions of most of the operators to work with classes

• In C++’s terminology, this is called operator overloading.

OPERATOR OVERLOADING

C++ allows the user to overload most of the operators to work effectively in a specific application.

C++ does not allow the user to create new operators. Most of the existing operators can be overloaded to manipulate class

objects. In order to overload an operator we must write functions. The name of the function that overloads an operator is the reserved

word operator followed by the operator to be overloaded. The following function name overloads >=

operator>=

Operator function: The function that overloads an operator.

Syntax for Operator FunctionsThe syntax of the heading of an operator function is

returnType operator operatorSymbol(arguments)

The operator function is a value-returning function.

In C++, operator is a reserved word.

To overload an operator for a class:

1. Include the function to overload the operator (that is, the operator function) in the definition of the class.

2. Write the definition of the operator function.

Overloading an Operator: Some RestrictionsWhen overloading an operator the following should be kept in mind.

1. You cannot change the precedence of an operator.2. The associativity cannot be changed. (For example, the

associativity of the arithmetic operator addition is from left to right and it cannot be changed.)

3. Default arguments cannot be used with an overloaded operator.4. You cannot change the number of arguments that an operator takes.5. You cannot create new operators. Only existing operators can be

overloaded. The operators that cannot be overloaded are

. .* :: ?: sizeof

6. The meaning of how an operator works with built-in types, such as int, remains the same.

7. Operators can be overloaded either for objects of the user-defined types, or for a combination of objects of the user-defined type and objects of the built-in type.

The following is a list of operators that can be overloaded.

+ - * / % ^ & |

! && || = == < <= >

>= != += -= *= /= %= ^=

|= &= << >> >>= <<= ++ --

->* , -> [] () ~ new delete

this Pointer Every object of a class maintains a (hidden) pointer to itself and the

name of this pointer is this. In C++, this is a reserved word. When an object invokes a member function, the this pointer of

the object is referenced by the member function. Suppose that test is a class and it has a member function, say one. Further suppose that the definition of one looks like:

test test::one()

{

.

.

.

return *this;

}

If x and y are objects of the type test, the statement

y = x.one();

returns the value of the object x to object y, that is, the data members of x will be copied into the corresponding data members of y.

When the object x invokes the function one, the pointer this in the definition of the member function one refers to the object x and so this means the address of x and *this means the value of x.

Example 16-1class thisPointerClass{public: void set(int a, int b, int c); void print() const;

thisPointerClass updateXYZ(); //Post: x = 2 * x; y = y + 2; // z = z * z;

thisPointerClass(int a = 0, int b = 0, int c = 0);

private: int x; int y; int z;};

void thisPointerClass::set(int a, int b, int c){ x = a; y = b; z = z;

}

void thisPointerClass::print() const{ cout<<"x = "<<x <<", y = "<<y <<", z = "<<z<<endl;

}

thisPointerClass thisPointerClass::updateXYZ(){

x = 2 * x; y = y + 2;z = z * z;

return *this;}

thisPointerClass::thisPointerClass(int a, int b, int c){

x = a;y = b;z = c;

}

int main(){thisPointerClass object1(3, 5, 7); //Line 1thisPointerClass object2; //Line 2

cout<<"Object 1: "; //Line 3object1.print(); //Line 4

object2 = object1.updateXYZ(); //Line 5

cout<<"After updating object1: "; //Line 6object1.print(); //Line 7

cout<<"Object 2: "; //Line 8object2.print(); //Line 9

return 0;}

Output

Object 1: x = 3, y = 5, z = 7After updating object1: x = 6, y = 7, z = 49Object 2: x = 6, y = 7, z = 49

Example 16-2class personType{public: void print() const; void setName(string first, string last); personType& setLastName(string last); //Function to set the last name //Post: lastName = last; //After setting the last name, a reference //to the object, that is, the address of the

//object, is returned personType& setFirstName(string first); //Function to set the first name //Post: firstName = last; //After setting the first name, a reference //to the object, that is, the address of the

//object, is returned void getName(string& first, string& last); personType(string first = "", string last = "");

private: string firstName; //store the first name string lastName; //store the last name};

personType& personType::setLastName(string last){lastName = last;

return *this;}

personType& personType::setFirstName(string first){firstName = first;

return *this;}

int main(){ personType student1("Angela", "Clodfelter"); //Line 1

personType student2; //Line 2

personType student3; //Line 3

cout<<"Line 4 -- Student 1: "; //Line 4 student1.print(); //Line 5 cout<<endl; //Line 6

student2.setFirstName("Shelly").setLastName("Malik"); //Line 7


student3.setFirstName("Chelsea"); //Line 11


student3.setLastName("Tomek"); //Line 15

cout<<"Line 16 -- Student 3: "; //Line 16

student3.print); //Line 17 cout<<endl; //Line 18

return 0;}

Output

Line 4 -- Student 1: Angela ClodfelterLine 8 -- Student 2: Shelly MalikLine 12 -- Student 3: ChelseaLine 16 -- Student 3: Chelsea Tomek

Friend Functions of Classes• A function that is defined outside the scope of a class is called a

friend function.

• A friend function is a nonmember function of the class, but has access to the private data members of the class.

• To make a function friend to a class, the reserved word friend precedes the function prototype (in the class definition).

• The word friend appears only in the function prototype (in the class definition), not in the definition of the friend function.

class classIllusFriend

{

friend void two(...);

.

.

.

};

In the definition of the class classIllusFriend, two is declared as a friend of the class classIllusFriend; that is, it is a nonmember function of the class classIllusFriend.

When you write the definition of the function two, any object of the type classIllusFriend—which is either a local variable of two or a formal parameter of two—can access its private members within the definition of the function two.

Because a friend function is not a member of a class, its declaration can be placed within the private, protected, or public part of the class.

Definition of a friend Function When writing the definition of the friend function, the name of the

class and the scope resolution operator does not precede the name of the friend function in the function heading.

The definition of the function two in the above class classIllusFriend is:

void two(...)

{

.

.

.

}

We will place the definition of the friend function in the implementation file.

Example 16-3

class classIllusFriend{ friend void two(classIllusFriend cLFObject);

public: void print(); void setx(int a);

private: int x;

};

void classIllusFriend::print(){cout<<"In class classIllusFriend: x = "<<x<<endl;

}

void classIllusFriend::setx(int a){

x = a;}

void two(classIllusFriend cLFObject) //Line 1{ classIllusFriend localTwoObject; //Line 2

localTwoObject.x = 45; //Line 3

localTwoObject.print(); //Line 4 cout<<endl; //Line 5 cout<<"Line 6: In Friend Function two accessing " <<"private data member x " <<localTwoObject.x<<endl; //Line 6

cLFObject.x = 88; //Line 7

cLFObject.print(); //Line 8 cout<<endl; //Line 9 cout<<"Line 10: In Friend Function two accessing " <<"private data member x " <<localTwoObject.x<<endl; //Line 10

}

int main(){classIllusFriend aObject; //Line 11

aObject.setx(32); //Line 12

cout<<"Line 13: aObject.x: "; //Line 13aObject.print(); //Line 14cout<<endl; //Line 15cout<<"*~*~*~*~*~* Testing Friend Function " <<"two *~*~*~*~*~*"<<endl<<endl; //Line 16

two(aObject); //Line 17

return 0;}

OutputLine 13: aObject.x: In class classIllusFriend: x = 32

*~*~*~*~*~* Testing Friend Function two *~*~*~*~*~*

In class classIllusFriend: x = 45

Line 6: In Friend Function two accessing private data member x 45

In class classIllusFriend: x = 88

Line 10: In Friend Function two accessing private data member x 45

Operator Functions as Member Functions and Nonmember Functions

1. The function that overloads any of the operators (), [], ->, or = for a class must be declared as a member of the class.

2. Suppose an operator op is overloaded for a class, say OpOverClass.

a. If the leftmost operand of op is an object of a different type (that is, not of the type OpOverClass), the function that overloads the operator op for OpOverClass must be a nonmember—that is, a friend of the class OpOverClass.

b. If the operator function that overloads the operator op for the class OpOverClass is a member of the class OpOverClass, then when applying op on objects of the type OpOverClass, the leftmost operand of op must be of the type OpOverClass.

• Except for some of the operators, as explained above, most of the operators can be overloaded either as member functions or as nonmember functions.

• The following class is used to illustrate operator overloading.

class OpOverClass{

.

.

.private: int a; int b;};

OpOverClass x;OpOverClass y;

OpOverClass z;.

Binary Operators as Member Functions• Suppose that the binary operator + is overloaded for the class OpOverClass.

Overloading + as a Member Function

• Suppose that + is overloaded as a member function of the class OpOverClass.

• The name of the function to overload + for the class OpOverClass is

operator+

• Since x and y are objects of the type OpOverClass, we can perform the operation

x + y

• The compiler translates this expression into the following expression:

x.operator+(y)

• In this expression, there is only one argument to the function operator+, which is y.

• In the above statement, operator+ has direct access to the private members of the object x.

• The first argument to operator+ is the object that is invoking the function operator+ and the second argument is passed as a parameter to this function.

• Suppose that the operator + adds the corresponding data members of the objects.

• The result of the expression

x + y

is an object of the type OpOverClass.

• The return type of the operator function operator+ is of the type OpOverClass.

• The function prototype of operator+ in the definition of the class OpOverClass is:

OpOverClass operator+(const OpOverClass&) const;

OpOverClass OpOverClass::operator+

(const OpOverClass& otherObject) const

{

OpOverClass temp;

temp.a = a + otherObject.a;

temp.b = b + otherObject.b;

return temp;

}

General Syntax to Overload Binary (Arithmetic) Operators as Member Functions

Function Prototype (to be included in the definition of the class):

returnType operator op(className);

• op stands for the binary operator to be overloaded. • returnType is the type of the value returned by the function. • className is the name of the class for which the operator is

being overloaded.

Function Definition:

returnType className::operator op

(const className& otherObject) const

{

//algorithm to perform the operation

return (value);

}

Example 16-4class OpOverClass{public: void print() const;

//Overload arithmetic operators OpOverClass operator+(const OpOverClass&) const; OpOverClass operator*(const OpOverClass&) const;

OpOverClass(int i = 0, int j = 0);

private: int a; int b;};

void OpOverClass::print() const{

cout<<"("<<a<<", "<<b<<")";}

OpOverClass::OpOverClass(int i, int j){

a = i;b = j;

}OpOverClass OpOverClass::operator+ (const OpOverClass& right) const{

OpOverClass temp;temp.a = a + right.a;temp.b = b + right.b;return temp;

}OpOverClass OpOverClass::operator* (const OpOverClass& right) const{

OpOverClass temp;temp.a = a * right.a;temp.b = b * right.b;return temp;

}

int main(){

OpOverClass u(23, 45); //Line 1OpOverClass v(12,10); //Line 2OpOverClass w1; //Line 3OpOverClass w2; //Line 4

cout<<"Line 5: u = "; //Line 5u.print(); //Line 6; output ucout<<endl; //Line 7

cout<<"Line 8: v = "; //Line 8v.print(); //Line 9; output vcout<<endl; //Line 10

w1 = u + v; //Line 11; add u and v

cout<<"Line 12: w1 = "; //Line 12w1.print(); //Line 13; output w1cout<<endl; //Line 14

w2 = u * v; //Line 15; multiply u and v

cout<<"Line 16: w2 = "; //Line 16w2.print(); //Line 17; output w2cout<<endl; //Line 18

return 0;}

Output

Line 5: u = (23, 45)Line 8: v = (12, 10)Line 12: w1 = (35, 55)Line 16: w2 = (276, 450)

Overloading Relational Operators as Member Functions

• We overload the equality operator, ==, for the class OpOverClass.

• Since the result of a relational operator is either true or false, the returnType of the function operator== is Boolean.

• The syntax of the function prototype to be included in the definition of the class OpOverClass is:

bool operator==(const OpOverClass&) const;

bool OpOverClass ::operator==

(const OpOverClass& right) const

{

return(a == right.a && b == right.b);

}

General Syntax to Overload Binary Relational Operators as Member Functions

Function Prototype

bool operator op(const className&) const;

• op is the relational operator that is being overloaded.• className is the name of the class for the operator op is being

overloaded.


bool className::operator op(const className& right)

const

{

//Compare and return the value

}

Binary Operators as Nonmember Functions

• Suppose that + is overloaded as a nonmember function of the class OpOverClass.

• Suppose that the following operation is to be performed.

x + y

• This expression is compiled as

operator+(x,y)

• The function operator+ has two arguments.

• The function operator+ is neither a member of the object x nor a member of the object y.

• The objects to be added are passed as arguments to the function operator+.

• To include the operator function operator+ as a nonmember of the class in the definition of the class the reserved word friend must appear before the function heading.

• The function operator+ must have two arguments.

• To include operator+ as a nonmember in the definition of the the class OpOverClass its prototype in the definition of OpOverClass is

friend OpOverClass operator+(const OpOverClass&,

const OpOverClass&);

OpOverClass operator+(

const OpOverClass& firstObject,

const OpOverClass& secondObject)

{

OpOverClass temp;

temp.a = firstObject.a + secondObject.a;

temp.b = firstObject.b + secondObject.b;

return temp;

}

• In the above definition, we add the corresponding data members of firstObject and secondObject and store the result in temp.

• Recall that the private members of a class are local to the class and therefore cannot be accessed outside the class.

• Following this rule, since operator+ is not a member of the class OpOverClass, in the definition of the function operator+, expressions such as firstObject.a must be illegal since a is a private member of firstObject.

• Since operator+ was declared as a friend function of the class OpOverClass, an object of the type OpOverClass can access its private members in the definition of operator+.

• In the function heading, the name of the class, that is, OpOverClass and the scope resolution operator is not included before the name of the function operator+ since the function operator+ is not a member of the class.

General Syntax to Overload Binary (Arithmetic) Operators as Nonmember Functions


friend returnType operator op(const className&,

const className&);

• op stands for the binary operator to be overloaded. • returnType is the type of the value returned by the function.• className is the name of the class for which the operator is

being overloaded.

Function Definition

returnType operator op(const className& firstObject,

const className& secondObject)

{

//algorithm to perform the operation

return (value);

}

Overloading Relational Operators as Nonmember Functions

• We overload the equality operator, ==, for the class OpOverClass.

• The return type of the function operator== is Boolean.

Function Prototype

friend bool operator==(const OpOverClass&,

const OpOverClass&);

Function Definition

bool operator==(const OpOverClass& firstObject,

const OpOverClass& secondObject)

{

return(firstObject.a == secondObject.a &&

firstObject.b == secondObject.b);

}

General Syntax to Overload Binary Relational Operators as Nonmember Functions


friend bool operator op(const className&, const className&);

• op is the relational operator that is being overloaded.• className is the name of the class for the operator op is being

overloaded.


bool operator op (const className& firstObject, const className& secondObject){

//Compare and return the value }

Overloading Stream Insertion (<<) and Extraction (>>) Operators• The operator function that overloads the insertion operator << or

the extraction operator >> for a class must be a nonmember of that class.

Consider the following expression.

cin>>x

In this expression, the left most operand of >>, that is, cin is an istream variable, not an object of the type OpOverClass.

Since the left most operand of >> is not an object of the type OpOverClass, the operator function that overloads the extraction operator for OpOverClass must be a nonmember of the class OpOverClass.

Similarly, the operator function that overloads the stream insertion operator for OpOverClass must be a nonmember function of OpOverClass.

Overloading the Stream Insertion Operator (<<)

The general syntax to overload the stream insertion operator << for a class is:


friend ostream& operator<<(ostream&, const className& );


ostream& operator<<(ostream& osObject, const className& object){ //local declaration if any //Output members of the object //osObject<<. . .

//return stream object return osObject;}

Overloading the Stream Extraction Operator (>>)

The general syntax to overload the stream extraction operator >> for a class is:

Function Prototype:friend istream& operator>>(istream&, className&);

Function Definition:istream& operator>>(istream& isObject, className& object){

//local declaration if any //Read data into the object //isObject>>. . .

//return stream object return isObject;}

Example 16-6

class OpOverClass{

//overload stream insertion and extraction operators friend ostream& operator<<(ostream&, const OpOverClass&); friend istream& operator>>(istream&, OpOverClass&);

public://overload arithmetic operators

OpOverClass operator+(const OpOverClass&) const; OpOverClass operator*(const OpOverClass&) const;

OpOverClass(int i = 0, int j = 0);

private: int a; int b;};

//Definitions of the functions operator+, operator*, //and the constructor are the same as in Example 16-4

ostream& operator<<(ostream& os, const OpOverClass& right){

os<<"("<<right.a<<", "<<right.b<<")";

return os;}

istream& operator>>(istream& is, OpOverClass& right){

is>>right.a>>right.b;

return is;}

int main(){

OpOverClass u(23, 45); //Line 1OpOverClass v; //Line 2

cout<<"Line 3: u : "<<u<<endl; //Line 3

cout<<"Line 4: Enter two integers: "; //Line 4cin>>v; //Line 5cout<<endl; //Line 6cout<<"Line 7: v : "<<v<<endl; //Line 7

cout<<"Line 8: u + v : "<<u + v<<endl;//Line 8cout<<"Line 9: u * v : "<<u * v<<endl;//Line 9

return 0;}

Sample Run: In this sample run, the user input is in red.

Line 3: u = (23, 45)Line 4: Enter two integers: 5 6

Line 7: v = (5, 6)Line 8: u + v = (28, 51)Line 9: u * v = (115, 270)

Overloading the Assignment Operator (=)

General Syntax to Overload the Assignment Operator = for a Class

Function Prototype:

const className& operator=(const className&);


const className& className::operator=

(const className& rightObject)

{

//local declaration, if any

if( this != &rightObject) //avoid self-assignment

{ //algorithm to copy the rightObject into this object

}

//return the object assigned

return *this;

}

Suppose that the assignment operator, =, is overloaded for the class OpOverClass.

The statement

x = y;

is equivalent to the statement

x.operator=(y);

Consider the statement

x = y = z;

Because the associativity of the operator = is from right to left, this statement is equivalent to the statement

x.operator=(y.operator=(z)); //Line B

We must first execute the expression

y.operator=(z)

The value returned by the expression

y.operator=(z)

will become the parameter to the function operator= so as to assign a value to the object x.

Because the formal parameter to the function operator= is a reference parameter, the expression

y.operator=(z)

must return a reference to the object, rather than its value. Now consider the statement

x = x;

Here we are trying to copy the value of x into x; that is, this statement is a self-assignment.

We must prevent such statements because they waste computer time. The body of the function operator= does prevent such assignments.

Consider the if statement in the body of the operator function operator=:

if(this != &rightObject) //avoid self-assignment{

//algorithm to copy the rightObject into this object}

The statement

x = x;

is compiled into the statement

x.operator=(x);

In the expression

this != &rightObject

this means the address of x, and &rightObject also means the address of x. Thus, the expression will evaluate to false and, the body of the if statement will be skipped.

Overloading Unary Operators

1. If the operator function is a member of the class, it has no parameters.

2. If the operator function is a nonmember, that is, a friend function of the class it has one parameter.

Overloading Increment (++) and Decrement (--) Operators• The increment operator has two forms, pre-increment (++u) and

post-increment (u++), where u is a variable, say of the type int.

• In the case of pre-increment (++u), the value of the variable (u) is incremented by 1 before using the value of u in an expression and in the case of post-increment the value of u is used in the expression before it is incremented by 1.

Pre-increment To overload the pre-increment operator, in the function definition first

we increment the value of the object and then use the this pointer to return the value of the object.

Suppose that we overload the pre-increment operator for the class OpOverClass. Also suppose that the operator function operator++ is a member of the class OpOverClass. Then the operator function operator++ has no arguments. Since the operator function operator++ has no arguments, we use the this pointer to return the incremented value of the object.

OpOverClass OpOverClass::operator++()

{

//increment the object

++a;

++b;

return *this; //return the incremented value of the object

}

The General Syntax to Overload the Pre-increment Operator ++ As a Member Function


className operator++();


className className::operator++()

{

//increment the value of the object by 1

return *this;

}

The operator function to overload the pre-increment operator can also be a nonmember of the class OpOverClass.

OpOverClass operator++(OpOverClass& incObj)

{

//increment the object

(incObj.a)++;

(incObj.b)++;

return incObj; //return the incremented value of the object

}

General Syntax to Overload the Pre-increment Operator ++ as a Nonmember Function

Function Prototype:

friend className operator++(className&);


className operator++(className& incObj)

{

//increment incObj by 1

return incObj;

}

Overloading the Post-increment Operator

Overload the post-increment operator for the class OpOverClass. In both cases, pre- and post-increment, the name of the operator function is

the operator++. To distinguish between pre- and post-increment operator overloading, we

use a dummy parameter (of the type int) in the function heading of the operator function.

The function prototype for the post-increment operator for the class OpOverClass is

OpOverClass operator++(int);

The statement

x++;

is compiled by the compiler in the statement

x.operator++(0);

and so the function operator++ with a parameter executes.

The parameter 0 is used merely to distinguish between the pre- and post-increment operator functions.

The steps required to implement this function are:

1. Save the value of the object—say, in temp.2. Increment the value of the object.3. Return the value that was saved in temp.

The function definition of the post-increment operator for the class OpOverClass is

OpOverClass OpOverClass::operator++(int u){ OpOverClass temp = *this; //use this pointer to copy //the value of the object //increment the object a++; b++;

return temp; //return the old value of the object}

The General Syntax to Overload the Post-increment Operator ++ as a Non Member Function


friend className operator++(className&, int);


className operator++(className& incObj, int u)

{

className temp = incObj; //copy incObj into temp

//increment incObj

return temp; //return the old value of the object

}

//Definition of the class OpOverClass//The increment, decrement, arithmetic, and relational//operator functions are members of the class.

class OpOverClass{ //overload the stream insertion and extraction operators friend ostream& operator<<(ostream&, const OpOverClass&);friend istream& operator>>(istream&, OpOverClass&);

public: //overload the arithmetic operators

OpOverClass operator+(const OpOverClass&) const; OpOverClass operator-(const OpOverClass&) const; OpOverClass operator*(const OpOverClass&) const; OpOverClass operator/(const OpOverClass&) const;

//overload the increment and decrement operators OpOverClass operator++(); //pre-increment OpOverClass operator++(int); //post-increment OpOverClass operator--(); //pre-decrement OpOverClass operator--(int); //post-decrement

//overload the relational operators bool operator==(const OpOverClass&) const; bool operator!=(const OpOverClass&) const; bool operator<=(const OpOverClass&) const; bool operator<(const OpOverClass&) const; bool operator>=(const OpOverClass&) const; bool operator>(const OpOverClass&) const;

//constructors OpOverClass(); OpOverClass(int i, int j);

//include other functions as needed

private:int a;int b;

};

//Definition of the class OpOverClass//The increment, decrement, arithmetic, and relational//operator functions are nonmembers of the class.

class OpOverClass{ //overload the stream insertion and extraction operators friend ostream& operator<<(ostream&, const OpOverClass&); friend istream& operator>>(istream&, OpOverClass&);

//overload the arithmetic operators friend OpOverClass operator+(const OpOverClass&, const OpOverClass&); friend OpOverClass operator-(const OpOverClass&, const OpOverClass&); friend OpOverClass operator*(const OpOverClass&, const OpOverClass&); friend OpOverClass operator/(const OpOverClass&, const OpOverClass&);

//overload the increment and decrement operators friend OpOverClass operator++(OpOverClass&); friend OpOverClass operator++(OpOverClass&, int); friend OpOverClass operator--(OpOverClass&); friend OpOverClass operator--(OpOverClass&, int);

//overload the relational operators friend bool operator==(const OpOverClass&, const OpOverClass&); friend bool operator!=(const OpOverClass&, const OpOverClass&); friend bool operator<=(const OpOverClass&, const OpOverClass&); friend bool operator<(const OpOverClass&, const OpOverClass&); friend bool operator>=(const OpOverClass&, const OpOverClass&); friend bool operator>(const OpOverClass&, const OpOverClass&);

public://constructors

OpOverClass(); OpOverClass(int i, int j);

//include other functions as needed

private:int a;int b;

};

Operator Overloading: Member Versus Nonmember Certain operators must be overloaded as member functions of the

class, and some must be overloaded as nonmember (friend) functions.

The binary arithmetic operator + can be overloaded as a member function or a nonmember function.

If you overload + as a member function, then the operator + has direct access to the data members of one of the objects, and you need to pass only one object as a parameter.

If you overload + as a nonmember function, then you must pass both objects as parameters.

Overloading + as a nonmember could require additional memory and computer time to make a local copy of the data.

For efficiency purposes, wherever possible, you should overload operators as member functions.

Classes and Pointer Data Members (Revisited)1. Explicitly overload the assignment operator

2. Include the copy constructor3. Include the destructor

Operator Overloading: One Final Word

PROGRAMMING EXAMPLE: CLOCKTYPE Chapter 12 defined a class clockType to implement the time of

day in a program. We implemented the operations print time, increment time, and

compare two times for equality using functions. This example redefines the class clockType. It also overloads the stream insertion and extraction operators for

easy input and output, relational operators for comparisons, and the increment operator to increment the time by one second.

The program that uses the class clockType requires the user to input the time in the form hr:min:sec.

//Header file newClock.h

#ifndef H_newClock#define H_newClock

class clockType{ friend ostream& operator<< (ostream&, const clockType&); friend istream& operator>> (istream&, clockType&);

public: void setTime(int hours, int minutes, int seconds);

//Function to set the private data members //hr, min, and sec //Post: hr = hours; min = minutes; sec = seconds

void getTime(int& hours, int& minutes, int& seconds);//Function to return the time//Post: hours = hr; minutes = min; seconds = sec;

clockType operator++(); //Overload the pre-increment operator

//Post: Time is incremented by one second

bool operator==(const clockType& otherClock) const; //Overload the equality operator//Function returns true if the time is equal //to otherTime, otherwise it returns the value false

bool operator<=(const clockType& otherClock) const;//Overload the less than or equal to operator//Function returns true if the time is less //than or equal to otherTime, otherwise it returns//the value false

clockType(int hours = 0, int minutes = 0, int seconds = 0);

//Constructor to initialize the object with the//values specified by the user. If no values are// specified, default values are assumed.//Post: hr = hours; min = minutes; sec = seconds

private: int hr; //variable to store the hours int min; //variable to store the minutes int sec; //variable to store the seconds};

//overload the preincrement operatorclockType clockType::operator++(){ sec++; //Step a

if(sec > 59) //Step b{ sec = 0; //Step b.1

min++; //Step b.2

if(min > 59) //Step b.3 {

min = 0; //Step b.3.1

hr++; //Step b.3.2

if(hr > 23) //Step b.3.3 hr = 0; //Step b.3.3.1

}}

return *this; //Step c}

//overload the equality operator

bool clockType::operator==

(const clockType& otherClock) const

{

return(hr == otherClock.hr && min == otherClock.min && sec == otherClock.sec);

}

//overload the less than or equal to operator

bool clockType::operator<=

(const clockType& otherClock) const

{

return((hr < otherClock.hr) ||

(hr == otherClock.hr && min < otherClock.min) ||

(hr == otherClock.hr && min == otherClock.min &&

sec <= otherClock.sec));

}

//constructor with parametersclockType::clockType(int hours, int minutes, int seconds){

if(0 <= hours && hours < 24) hr = hours;else hr = 0;

if(0 <= minutes && minutes < 60) min = minutes;else min = 0;

if(0 <= seconds && seconds < 60) sec = seconds;else sec = 0;

}

void clockType::setTime(int hours, int minutes, int seconds){

if(0 <= hours && hours < 24) hr = hours;else hr = 0;

if(0 <= minutes && minutes < 60) min = minutes;else min = 0;

if(0 <= seconds && seconds < 60) sec = seconds;else sec = 0;

}

void clockType::getTime(int& hours, int& minutes, int& seconds){

hours = hr;minutes = min;seconds = sec;

}

The time must be output in the form

hh:mm:ss

//overload the stream insertion operatorostream& operator<< (ostream& osObject, const clockType& timeOut){

if(timeOut.hr < 10) osObject<<'0';osObject<<timeOut.hr<<':';

if(timeOut.min < 10) osObject<<'0';osObject<<timeOut.min<<':';

if(timeOut.sec < 10) osObject<<'0';osObject<<timeOut.sec;

return osObject; //return the ostream object}

The input to the program is of the form

hh:mm:ss

//overload the stream extraction operator

istream& operator>> (istream& isObject,

clockType& timeIn)

{

char ch;

isObject>>timeIn.hr; //Step a

isObject.get(ch); //Step b; read and discard :

isObject>>timeIn.min; //Step c

isObject.get(ch); //Step d; read and discard :

isObject>>timeIn.sec; //Step e

return isObject; //Step f

}

//Program that uses the class clockType

#include <iostream>#include "newClock.h"

using namespace std;

int main(){

clockType myClock(5,6,23); //Line 1clockType yourClock; //Line 2

cout<<"Line 3: myClock = "<<myClock<<endl; //Line 3cout<<"Line 4: yourClock = "<<yourClock<<endl;

//Line 4

cout<<"Line 5: Enter time in the form " <<"hr:min:sec "; //Line 5cin>>myClock; //Line 6cout<<"Line 7: The new time of myClock = " <<myClock<<endl; //Line 7

++myClock; //Line 8

cout<<"Line 9: After increment the time, myClock = " <<myClock<<endl; //Line 9

yourClock.setTime(13,35,38); //Line 10cout<<"Line 11: After setting the time, yourClock = " <<yourClock<<endl; //Line 11

if(myClock == yourClock) //Line 12 cout<<"Line 13: The times of myClock and "

<<"yourClock are equal"<<endl; //Line 13else //Line 14 cout<<"Line 15: The times of myClock and "

<<"yourClock are not equal"<<endl; //Line 15

if(myClock <= yourClock) //Line 16 cout<<"Line 17: The time of myClock is less "

<<"than or equal to "<<endl <<"the time of yourClock"<<endl; //Line 17

else //Line 18 cout<<"Line 19: The time of myClock is "

<<"greaterthan the time of yourClock" <<endl; //Line 19

return 0;}

Sample Run In this sample run, the user input is in red.Line 3: myClock = 05:06:23Line 4: yourClock = 00:00:00Line 5: Enter the time in the form hr:min:sec 4:50:59Line 7: The new time of myClock = 04:50:59Line 9: After increment the time, myClock = 04:51:00Line 11: After setting the time, yourClock = 13:35:38Line 15: The times of myClock and yourClock are not equalLine 17: The time of myClock is less than or equal tothe time of yourClock

PROGRAMMING EXAMPLE: COMPLEX NUMBERSA number of the form a + ib, where i2 = -1, and a and b are real numbers, is called a complex number. We call a the real part and b the imaginary part of a + ib. Complex numbers can also be represented as ordered pairs (a, b). The addition and multiplication of complex numbers is defined by the following rules:

(a + ib) + (c + id) = (a + c) + i(b + d)

(a + ib) * (c + id) = (ac - bd) + i(ad + bc)

Using the ordered pair notation

(a + ib) + (c + id) = (a + c) + i(b + d)

(a + ib) * (c + id) = (ac - bd) + i(ad + bc)

//Specification file complexType.h#ifndef H_complexNumber#define H_complexNumber

class complexType{ friend ostream& operator<< (ostream&, const complexType&); friend istream& operator>> (istream&, complexType&);

public: void setComplex(const double& real, const double& imag);

complexType(double real = 0, double imag = 0); complexType operator+(const complexType& otherComplex) const; complexType operator*(const complexType& otherComplex) const; bool operator==(const complexType& otherComplex) const;

private: double realPart; double imaginaryPart; };#endif

To output the complex number in the form

(a, b)

where a is the real part and b is the imaginary part

ostream& operator<<(ostream& osObject, const complexType& complex)

{osObject<<"("; //Step a

osObject<<complex.realPart; //Step b osObject<<", "; //Step c osObject<<complex.imaginaryPart; //Step d osObject<<")"; //Step e

return osObject; //Return the ostream object}

Now the input is of the form, say

(3, 5)

istream& operator>> (istream& isObject, complexType& complex){

char ch;

isObject>>ch; //Step aisObject>>complex.realPart; //Step bisObject>>ch; //Step cisObject>>complex.imaginaryPart; //Step disObject>>ch; //Step e

return isObject; //Return the istream object}

bool complexType::operator==(const complexType& otherComplex) const{

return(realPart == otherComplex.realPart && imaginaryPart == otherComplex.imaginaryPart);

}

//constructor complexType::complexType(double real, double imag){

realPart = real;imaginaryPart = imag;

}

void complexType::setComplex(const double& real, const double& imag){

realPart = real;imaginaryPart = imag;

}

//overload the operator +complexType complexType::operator+ (const complexType& otherComplex) const{

complexType temp;

temp.realPart = realPart + otherComplex.realPart;temp.imaginaryPart = imaginaryPart

+ otherComplex.imaginaryPart;

return temp;}

//overload the operator *complexType complexType::operator* (const complexType& otherComplex) const{ complexType temp;

temp.realPart = (realPart * otherComplex.realPart) - (imaginaryPart * otherComplex.imaginaryPart); temp.imaginaryPart = (realPart * otherComplex.imaginaryPart) + (imaginaryPart * otherComplex.realPart); return temp;}

//Program that uses the class complexType

#include <iostream>#include "complexType.h"


int main(){

complexType num1(23,34); //Line 1complexType num2; //Line 2complexType num3; //Line 3

cout<<"Line 4: Num1 = "<<num1<<endl; //Line 4cout<<"Line 5: Num2 = "<<num2<<endl; //Line 5

cout<<"Line 6: Enter the complex number " <<"in the form (a,b) "; //Line 6cin>>num2; //Line 7cout<<endl; //Line 8

cout<<"Line 9: New value of num2 = " <<num2<<endl; //Line 9

num3 = num1 + num2; //Line 10

cout<<"Line 11: Num3 = "<<num3<<endl; //Line 11cout<<"Line 12: "<<num1<<" + "<<num2 <<" = "<<num1 + num2<<endl; //Line 12cout<<"Line 13: "<<num1<<" * "<<num2 <<" = "<<num1 * num2<<endl; //Line 13

return 0;}


Line 4: Num1 = (23, 34)Line 5: Num2 = (0, 0)Line 6: Enter the complex number in the form (a,b) (3,4)

Line 9: New value of num2 = (3, 4)Line 11: Num3 = (26, 38)Line 12: (23, 34) + (3, 4) = (26, 38)Line 13: (23, 34) * (3, 4) = (-67, 194)

OVERLOADING THE ARRAY INDEX (SUBSCRIPT) OPERATOR ([])

The function to overload the operator [] for a class must be a member of the class.

Since an array can be declared as constant or non-constant, we need to overload the operator [] to handle both the cases.

The syntax to declare the operator function operator[] as a member of a class for non-constant arrays is:

Type& operator[](int index);

The syntax to declare the operator function operator[] as a member of a class for constant arrays is:

const Type& operator[](int index) const;

where Type is the data type of the array elements.

• Suppose classTest is a class that has an array data member. The definition of classTest to overload the operator function operator [] is:

class classTest{public: Type& operator[](int index); //overload the operator for nonconstant arrays const Type& operator[](int index) const; //overload the operator for constant arrays

.

.

.private: Type *list; //pointer to the array int arraySize;};

where Type is the data type of the array elements.

//overload the operator [] for nonconstant arrays

Type& classTest::operator[](int index)

{

assert(0 <= index && index < arraySize);

return(list[index]); //return a pointer of the

//array component

}

//overload the operator [] for constant arrays

const Type& classTest::operator[](int index) const

{

assert(0 <= index && index < arraySize);

return(list[index]); //return a pointer of the

//array component

}

classTest list1;

classTest list2;

const classTest list3;

In the case of the statement

list1[2] = list2[3];

the body of the operator function operator[] for nonconstant arrays is executed.

In the case of the statement

list1[2] = list3[5];

first the body of the operator function operator[] for constant arrays is executed because list3 is a constant array. Next, the body of the operator function operator[] for nonconstant arrays is executed to complete the execution of the assignment statement.

PROGRAMMING EXAMPLE: newString Recall that

1. A C string is a sequence of one or more characters,2. C strings are enclosed in double quote marks,3. C strings are null terminated, and4. C strings stored in character arrays.

In this example, by a string we mean a C string. The only allowable aggregate operations on strings are input and

output. To use other operations, the programmer need to include the header

file cstring, which contains the specification of many functions for string manipulation.

We define a class for string manipulation and at the same time to further illustrate operator overloading.

//Header file myString.h#ifndef H_myString#define H_myString#include <iostream>using namespace std;

class newString{

//overload the stream insertion and extraction operators friend ostream& operator<<(ostream&, const newString&); friend istream& operator>>(istream&, newString&);

public: const newString& operator=(const newString&);

//overload the assignment operator newString(const char *); //constructor; conversion from the char string newString(); //default constructor to initialize the string to null newString(const newString&); //copy constructor

~newString(); //destructor

char &operator[] (int); const char &operator[](int) const;

//overload the relational operators bool operator==(const newString&) const; bool operator!=(const newString&) const; bool operator<=(const newString&) const; bool operator<(const newString&) const; bool operator>=(const newString&) const; bool operator>(const newString&) const;

private: char *strPtr; //pointer to the char array //that holds the string int strLength; //data member to store the length //of the string};#endif

//Implementation file myString.cpp

#include <iostream>

#include <iomanip>

#include <cstring>

#include <cassert>

#include "myString.h"


//constructor: conversion from the char string to newStringnewString::newString(const char *str) { strLength = strlen(str); strPtr = new char[strLength+1]; //allocate //memory to store the char string

assert(strPtr != NULL); strcpy(strPtr,str); //copy string into strPtr}

//default constructor to store the null stringnewString::newString() {

strLength = 1;strPtr = new char[1];assert(strPtr != NULL);strcpy(strPtr,"");

}

//copy constructornewString::newString(const newString& rightStr){

strLength = rightStr.strLength;strPtr = new char[strLength + 1];assert(strPtr != NULL);strcpy(strPtr, rightStr.strPtr);

}

newString::~newString() //destructor{

delete [] strPtr;}

//overload the assignment operatorconst newString& newString::operator= (const newString& rightStr){

if(this != &rightStr) //avoid self-copy{ delete [] strPtr; strLength = rightStr.strLength; strPtr = new char[strLength + 1]; assert(strPtr != NULL); strcpy(strPtr, rightStr.strPtr);}return *this;

}

char& newString::operator[] (int index){

assert(0 <= index && index < strLength);return strPtr[index];

}

const char& newString::operator[](int index) const{

assert(0 <= index && index < strLength);return strPtr[index];

}

//overload the relational operatorsbool newString::operator== (const newString& rightStr) const{

return(strcmp(strPtr, rightStr.strPtr) == 0);}

bool newString::operator<(const newString& rightStr) const{

return(strcmp(strPtr, rightStr.strPtr) < 0);}

bool newString::operator<=(const newString& rightStr) const{

return(strcmp(strPtr, rightStr.strPtr) <= 0);}

bool newString::operator>(const newString& rightStr) const{

return(strcmp(strPtr, rightStr.strPtr) > 0);}

bool newString::operator>=(const newString& rightStr) const{

return(strcmp(strPtr, rightStr.strPtr) >= 0);}

bool newString::operator!=(const newString& rightStr) const{

return(strcmp(strPtr, rightStr.strPtr) != 0);}

//overload the stream insertion operator << ostream& operator<<(ostream& osObject, const newString& str){

osObject<<str.strPtr;return osObject;

}

//overload the stream extraction operator >> istream& operator>>(istream& isObject, newString& str){

char temp[81];

isObject>>setw(81)>>temp;str = temp;

return isObject;}

• The conversion constructor is a single parameter function and converts its argument to the object of constructor’s class. In this example, the conversion constructor is used to convert a string to an object of the newString type.

• Note that the assignment operator is explicitly overloaded only for objects of newString type. However, the overloaded assignment operator also works if we want to store a character string into a newString object.

Consider the declaration

newString str;

and the statement

str = "Hello there";

The compiler translates this statement into the statement

str.operator=("Hello there");

Now,

1.First the compiler automatically invokes the conversion constructor to create an object of newString type to temporarily store the string "Hello there".

2. Second the compiler invokes the overloaded assignment operator to assign the temporary newString object to object str.

//Test Program#include <iostream>#include <cstring>#include "myString.h"


int main(){ newString s1 = "Sunny"; //initialize s1 using //the assignment operator const newString s2("Warm"); //initialize s2 using //the conversion constructor newString s3; //initialize s3 to null newString s4; //initialize s4 to null

cout<<"Line 1: "<<s1<<" "<<s2<<" ***" <<s3 <<"###."<<endl; //Line 1

if(s1 <= s2) //compare s1 and s2; Line 2cout<<"Line 3: "<<s1<<" is less than "<<s2

<<endl; //Line 3 else //Line 4

cout<<"Line 5: "<<s2<<" is less than "<<s1 <<endl; //Line 5

cout<<"Line 6: Enter a string of length " <<"at least 7 --> "; //Line 6 cin>>s1; //input s1; Line 7 cout<<endl<<"Line 8: New value of s1 = "<<s1 <<endl; //Line 8

s4 = s3 = "Birth Day"; //Line 9 cout<<"Line 10: s3 = "<<s3<<", s4 = "<<s4<<endl; //Line 10

s3 = s1; //Line 11 cout<<"Line 12: The new value of s3 = "<<s3<<endl; //Line 12

s1 = "Bright Sky"; //Line 13

s3[1] = s1[5]; //Line 14 cout<<"Line 15: After replacing the second character of s3 = " <<s3<<endl; //Line 15

s3[2] = s2[3]; //Line 16 cout<<"Line 17: After replacing the third character of s3 = " <<s3<<endl; //Line 17

s3[5] = 'g'; //Line 18 cout<<"Line 19: After replacing the sixth character of s3 = " <<s3<<endl; //Line 19

return 0;}


Line 1: Hello Happy ***###.

Line 5: Sunny is less than Warm

Line 6: Enter a string of length at least 7 --> 123456789

Line 8: New value of s1 = 123456789

Line 10: s3 = Birth Day, s4 = Birth Day

Line 12: The new value of s3 = 123456789

Line 15: After replacing the second character of str3 = 1t3456789

Line 17: After replacing the third character of str3 = 1tW456789

Line 19: After replacing the sixth character of str3 = 1tW45g789

FUNCTION OVERLOADING• Overloading a function refers to several functions with the same

name, but different parameters. The types of parameters determine which function to be executed.

int largerInt (int x, int y);

char largerChar(char first, char second);

double largerFloat(double u, double v);

newString largerString(newString first,

newString second);

int larger(int x, int y);

char larger(char first, char second);

double larger(double u, double v);

newString larger(newString first,

newString second);

Function overloading is used when we have the same action for different sets of data. However, for function overloading to work, we must give the definition of each of the functions.

TEMPLATES By using templates we write a single code for a set of related

functions- called function template and related classes- called class template.

The syntax for templates is:

template <class Type> declaration;

where Type is the type of the data and declaration is either a function declaration or a class declaration.

In C++, template is a reserved word. The word class in the heading refers to any user-defined type or

built in type. Type is referred as a formal parameter to the template. Just as variables are parameters to functions, types (that is, data

types) are parameters to templates.

Function Templates• The syntax for function template is

template <class Type>

function definition;

where Type is referred to as a formal parameter of the template and it is used to specify the type of the parameters to the function and the return type of the function, and to declare variables within the function.

template <class Type>Type larger(Type x, Type y){

if(x >= y) return x;

else return y;

}

The statement

cout<<larger(5,6)<<endl;

is a call to the function template larger. Since 5 and 6 are of the type int, data type int is substituted for Type and the compiler generates the appropriate code.

In the function template definition if we omit the body of the function, the function template then, as usual, is the prototype.

Example 16-8 #include <iostream>#include "myString.h"using namespace std;template <class Type>Type larger(Type x, Type y);int main(){

cout<<"Line 1: Larger of 5 and 6 = " <<larger(5,6)<<endl; //Line 1cout<<"Line 2: Larger of A and B = " <<larger('A','B')<<endl; //Line 2cout<<"Line 3: Larger of 5.6 and 3.2 = " <<larger(5.6,3.2)<<endl; //Line 3newString str1 = "Hello"; //Line 4newString str2 = "Happy"; //Line 5cout<<"Line 6: Larger of "<<str1<<" and " <<str2<<" = "<<larger(str1, str2) <<endl; //Line 6return 0;

}

template<class Type>Type larger(Type x, Type y){

if(x >= y) return x;else return y;

}

OutputLine 1: Larger of 5 and 6 = 6Line 2: Larger of A and B = BLine 3: Larger of 5.6 and 3.2 = 5.6Line 6: Larger of Hello and Happy = Hello

Class Templates Like function templates, class templates are used to write a single

code segment for a set of related classes.

Syntax:

template<class Type>

class declaration

Class templates are called parameterized types since based on the parameter type a specific class is generated.

template <class elemType>class listType{public: bool isEmpty(); bool isFull(); void search(const elemType& searchItem, bool& found); void insert(const elemType& newElement); void remove(const elemType& removeElement); void destroyList(); void printList(); listType();

private: elemType list[100]; //array to hold the list elements int length; //variable to store the number of //elements in the list};

The statement

listType<int> intList; //Line 1

declares intList to be a list of 100 components and each component is of the type int.

The statement

listType<newString> stringList; //Line 2

declares stringList to be a list of 100 components and each component is of the type newString.

In the statements in Lines 1 and 2, listType<int> and listType<newString> are referred to as template instantiations or instantiations of the class template listType<elemType>, where elemType is the class parameter in the template header.

A template instantiation can be created with either a built-in or user-defined type.

The function members of a class template are considered function templates.

The definition of the member insert of the class listType is

template<class Type>

void listType<Type>::insert(Type newElement)

{

.

.

.

}

• In the heading of the member function’s definition the name of the class is specified with the parameter Type.

Header File and Implementation File of a Class Template Until now, we have placed the definition of the class and the definition of

the member functions in separate files. The object code was generated from the implementation file and linked with

the user code. Passing parameters to a function has an effect at run time, whereas passing a

parameter to a class template has an effect at compile time. Because the actual parameter to a class is specified in the client code, and

because the compiler cannot instantiate a function template without the actual parameter to the template, we can no longer compile the implementation file independently of the client code.

We could put the class definition and the definitions of the function templates directly in the client code, or we could put the class definition and the definitions of the function templates together in the same header file.

Another alternative is to put the class definition and the definitions of the functions in separate files, but include a directive to the implementation file at the end of the header file. In either case, the function definitions and the client code are compiled together.

We will put the class definition and the function definitions in the same header file.

Example 16-9 //Header file listType.h#ifndef H_listType#define H_listType

#include <iostream>#include <cassert>using namespace std;

template <class elemType>class listType{public: bool isEmpty(); bool isFull(); int getLength(); int getMaxSize(); void sort(); void print() const; void insertAt(const elemType& item, int position); listType(int listSize = 50); ~listType();

private: int maxSize; //maximum number that can be //stored in the list int length; //number of elements in the list elemType *list; //pointer to the array that //holds the list elements};

template<class elemType>bool listType<elemType>::isEmpty(){

return (length == 0)}

template<class elemType>bool listType<elemType>::isFull(){

return (length == maxSize);}

template<class elemType>int listType<elemType>::getLength(){

return length;}

template<class elemType>int listType<elemType>::getMaxSize(){

return maxSize;}

//constructor; the default array size is 50template<class elemType>listType<elemType>::listType(int listSize) {

maxSize = listSize;length = 0;list = new elemType[maxSize];

}

template<class elemType>listType<elemType>::~listType() //destructor{

delete [] list;}template<class elemType>void listType<elemType>::sort() //selection sort{

int i, j;int min;elemType temp;for(i = 0; i <length; i++){

min = i;for(j = i+1; j < length; ++j) if(list[j] < list[min])

min = j;temp = list[i];list[i] = list[min];list[min] = temp;

}//end for}//end sort

template<class elemType>void listType<elemType>::print() const{

int i;for(i = 0; i < length; ++i)

cout<<list[i]<<" ";cout<<endl;

}//end print

template<class elemType>void listType<elemType>::insertAt (const elemType& item, int position){

assert(position >= 0 && position < maxSize);list[position] = item;length++;

}

#endif

//Program to test the class listType

#include <iostream>#include "listType.h"#include "myString.h"using namespace std;

int main(){ listType<int> intList(100); //Line 1 listType<newString> stringList; //Line 2

int counter; //Line 3 int number; //Line 4

cout<<"List 5: Processing the integer List" <<endl; //Line 5 cout<<"List 6: Enter 5 integers: ";//Line 6

for(counter = 0; counter < 5; counter++)//Line 7 {

cin>>number; //Line 8intList.insertAt(number,counter); //Line 9

}

cout<<endl; //Line 10 cout<<"List 11: The list you entered is: "; //Line 11 intList.print(); //Line 12 cout<<endl; //Line 13 cout<<"Line 14: After sorting, the list is: ";//Line 14 intList.sort(); //Line 15 intList.print(); //Line 16 cout<<endl; //Line 17

newString str; //Line 18

cout<<"Line 19: Processing the string List" <<endl; //Line 19

cout<<"Line 20: Enter 5 strings: ";//Line 20

for(counter = 0; counter < 5; counter++)//Line 21 {

cin>>str; //Line 22stringList.insertAt(str,counter); //Line 23

}

cout<<endl; //Line 24 cout<<"Line 25: The list you entered is: " <<endl; //Line 25

stringList.print(); //Line 26 cout<<endl; //Line 27 cout<<"Line 28: After sorting, the list is: " <<endl; //Line 28 stringList.sort(); //Line 29 stringList.print(); //Line 30 cout<<endl; //Line 31

int intListSize; //Line 32

cout<<"Line 33: Enter the size of the integer " <<list: "; //Line 33 cin>>intListSize; //Line 34

listType<int> intList2(intListSize); //Line 35

cout<<"Line 36: Processing the integer List" <<endl; //Line 36 cout<<"Line 37: Enter "<<intListSize

<<" integers: "; //Line 37

for(counter = 0; counter < intListSize; counter++) //Line 38 {

cin>>number; //Line 39intList2.insertAt(number,counter); //Line 40

}

cout<<endl; //Line 41 cout<<"Line 42: The list you entered is: "<<endl;

//Line 42 intList2.print(); //Line 43 cout<<endl; //Line 44 cout<<"Line 45: After sorting, the list is: " <<endl; //Line 45 intList2.sort(); //Line 46 intList2.print(); //Line 47 cout<<endl; //Line 48 cout<<"Line 49: Length of the list = "

<<intList2.getLength()<<endl; //Line 49 cout<<"Line 50: Maximum size of the list = "

<<intList2.getMaxSize()<<endl; //Line 50

return 0;}

Sample Run: In this sample run, the use input is in red.List 5: Processing the integer ListList 6: Enter 5 integers: 19 15 66 24 34

List 11: The list you entered is: 19 15 66 24 34

Line 14: After sorting, the list is: 15 19 24 34 66

Line 19: Processing the string ListLine 20: Enter 5 strings: summer cold winter warm sunny

Line 25: The list you entered is:summer cold winter warm sunny

Line 28: After sorting, the list is:cold summer sunny warm winter

Line 33: Enter the size of the integer list: 10Line 36: Processing the integer ListLine 37: Enter 10 integers: 23 65 34 8 11 5 3 16 45 2

Line 42: The list you entered is:23 65 34 8 11 5 3 16 45 2

Line 45: After sorting, the list is:2 3 5 8 11 16 23 34 45 65

Line 49: Length of the list = 10Line 50: Maximum size of the list = 10

CHAPTER 15 OVERLOADING AND TEMPLATES. In this chapter, you will: Learn about overloading Become...

Documents

Transcript of CHAPTER 15 OVERLOADING AND TEMPLATES. In this chapter, you will: Learn about overloading Become...