chapter 6 3 overloading and templates n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CHAPTER 6\_3 OVERLOADING AND TEMPLATES PowerPoint Presentation
Download Presentation
CHAPTER 6\_3 OVERLOADING AND TEMPLATES

Loading in 2 Seconds...

play fullscreen
1 / 144

CHAPTER 6\_3 OVERLOADING AND TEMPLATES - PowerPoint PPT Presentation


  • 96 Views
  • Uploaded on

CHAPTER 6_3 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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CHAPTER 6\_3 OVERLOADING AND TEMPLATES' - amos


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide2
In this chapter, you will:
  • Learn about overloading
  • Become aware of the restrictions on operator overloading
  • Examine the pointer this
  • Learn about friendfunctions
  • 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
slide3
The capability of combining data and operations on data is called encapsulation. This is the first principle of OOD.
  • In Chapter 13, we also defined abstract data type (ADT) and discussed how classes in C++ implement ADT.
  • In Chapter 14, 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 14, and encourages code reuse.
slide4
WHY OPERATOR OVERLOADING IS NEEDED
  • Recall the class clockType as defined in Chapter 13.
  • Consider the following statements.

clockTypemyClock(8,23,34);

clockTypeyourClock(4,5,30);

myClock.printTime();

myClock.incrementSeconds();

if(myClock.equalTime(yourClock))

.

.

.

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

cout<<myClock;

myClock++;

if(myClock == yourClock)

.

.

.

slide6
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.
slide7
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.
slide8
Syntax for Operator Functions

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

slide9
Overloading an Operator: Some Restrictions

When 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 asint, 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.

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

+ - * / % ^ & |

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

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

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

->* , -> [] () ~ newdelete

slide11
this Pointer
  • Every object of a class maintains a (hidden) pointer to itself and the name of this pointer is this.
  • In C++,thisis a reserved word.
  • When an object invokes a member function, thethispointer 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;

}

slide12
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 *thismeans the value of x.
slide13
Example 16-1

class 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;

};

slide14
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;

}

slide16
int main()

{

thisPointerClass object1(3, 5, 7); //Line 1

thisPointerClass object2; //Line 2

cout<<"Object 1: "; //Line 3

object1.print(); //Line 4

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

cout<<"After updating object1: "; //Line 6

object1.print(); //Line 7

cout<<"Object 2: "; //Line 8

object2.print(); //Line 9

return 0;

}

Output

Object 1: x = 3, y = 5, z = 7

After updating object1: x = 6, y = 7, z = 49

Object 2: x = 6, y = 7, z = 49

slide17
Example 16-2

class 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 = "");

slide18
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;

}

slide19
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

cout<<"Line 8 -- Student 2: "; //Line 8

student2.print(); //Line 9

cout<<endl; //Line 10

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

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

student3.print(); //Line 13

cout<<endl; //Line 14

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

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

student3.print); //Line 17

cout<<endl; //Line 18

return 0;

}

Output

Line 4 -- Student 1: Angela Clodfelter

Line 8 -- Student 2: Shelly Malik

Line 12 -- Student 3: Chelsea

Line 16 -- Student 3: Chelsea Tomek

slide21
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.
slide22
class classIllusFriend

{

friendvoid two(...);

.

.

.

};

  • In the definition of the classclassIllusFriend, two is declared as a friend of the class classIllusFriend; that is, it is a nonmember function of the classclassIllusFriend.
  • 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.
slide23
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.
slide24
Example 16-3

class classIllusFriend

{

friendvoid 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;

}

slide25
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

}

slide26
int main()

{

classIllusFriend aObject; //Line 11

aObject.setx(32); //Line 12

cout<<"Line 13: aObject.x: "; //Line 13

aObject.print(); //Line 14

cout<<endl; //Line 15

cout<<"*~*~*~*~*~* Testing Friend Function "

<<"two *~*~*~*~*~*"<<endl<<endl; //Line 16

two(aObject); //Line 17

return 0;

}

slide27
Output

Line 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

slide28
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 classOpOverClass.

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

slide29
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;.

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

Overloading + as a Member Function

  • Suppose that + is overloaded as a member function of the classOpOverClass.
  • The name of the function to overload + for the classOpOverClass is

operator+

slide31
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.
slide32
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;

slide33
OpOverClass OpOverClass::operator+

(const OpOverClass& otherObject) const

{

OpOverClass temp;

temp.a = a + otherObject.a;

temp.b = b + otherObject.b;

return temp;

}

slide34
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.
slide35
Function Definition:

returnType className::operator op

(const className& otherObject) const

{

//algorithm to perform the operation

return (value);

}

slide36
Example 16-4

class 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<<")";

}

slide37
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;

}

slide38
int main()

{

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

OpOverClass v(12,10); //Line 2

OpOverClass w1; //Line 3

OpOverClass w2; //Line 4

cout<<"Line 5: u = "; //Line 5

u.print(); //Line 6; output u

cout<<endl; //Line 7

cout<<"Line 8: v = "; //Line 8

v.print(); //Line 9; output v

cout<<endl; //Line 10

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

cout<<"Line 12: w1 = "; //Line 12

w1.print(); //Line 13; output w1

cout<<endl; //Line 14

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

cout<<"Line 16: w2 = "; //Line 16

w2.print(); //Line 17; output w2

cout<<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)

slide40
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:

booloperator==(const OpOverClass&) const;

slide41
bool OpOverClass ::operator==

(const OpOverClass& right) const

{

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

}

slide42
General Syntax to Overload Binary Relational Operators as Member Functions

Function Prototype

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

Function Definition:

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

const

{

//Compare and return the value

}

slide43
Binary Operators as Nonmember Functions
  • Suppose that + is overloaded as a nonmember function of the classOpOverClass.
  • 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+.
slide44
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 classOpOverClass its prototype in the definition of OpOverClass is

friend OpOverClassoperator+(const OpOverClass&,

const OpOverClass&);

slide45
OpOverClass operator+(

const OpOverClass& firstObject,

const OpOverClass& secondObject)

{

OpOverClass temp;

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

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

return temp;

}

slide46
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 classOpOverClass, 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 classOpOverClass, 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.
slide47
General Syntax to Overload Binary (Arithmetic) Operators as Nonmember Functions

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

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.
slide48
Function Definition

returnType operator op(const className& firstObject,

const className& secondObject)

{

//algorithm to perform the operation

return (value);

}

slide49
Overloading Relational Operators as Nonmember Functions
  • We overload the equality operator, ==, for the classOpOverClass.
  • The return type of the function operator== is Boolean.

Function Prototype

friendbooloperator==(const OpOverClass&,

const OpOverClass&);

slide50
Function Definition

booloperator==(const OpOverClass& firstObject,

const OpOverClass& secondObject)

{

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

firstObject.b == secondObject.b);

}

slide51
General Syntax to Overload Binary Relational Operators as Nonmember Functions

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

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

Function Definition:

booloperator op (const className& firstObject,

const className& secondObject)

{

//Compare and return the value

}

slide52
Overloading Stream Insertion (<<) and Extraction (>>) Operators
  • The operator function that overloads the insertion operator << orthe 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 classOpOverClass.
  • Similarly, the operator function that overloads the stream insertion operator for OpOverClass must be a nonmemberfunction of OpOverClass.
slide53
Overloading the Stream Insertion Operator (<<)

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

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

friend ostream& operator<<(ostream&,

const className& );

Function Definition:

ostream& operator<<(ostream& osObject,

const className& object)

{

//local declaration if any

//Output members of the object

//osObject<<. . .

//return stream object

return osObject;

}

slide54
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;

}

slide55
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;

};

slide56
//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;

}

slide57
int main()

{

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

OpOverClass v; //Line 2

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

cout<<"Line 4: Enter two integers: "; //Line 4

cin>>v; //Line 5

cout<<endl; //Line 6

cout<<"Line 7: v : "<<v<<endl; //Line 7

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

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

return 0;

}

slide58
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)

slide59
Overloading the Assignment Operator (=)

General Syntax to Overload the Assignment Operator = for a Class

Function Prototype:

const className& operator=(const className&);

slide60
Function Definition:

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;

}

slide61
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)

slide62
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.
slide63
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.

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

slide65
Overloading Increment (++) and Decrement (--) Operators
  • The increment operatorhastwo forms, pre-increment (++u) and post-increment (u++), where u is a variable, say of the typeint.
  • 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.
slide66
Suppose that we overload the pre-increment operator for the classOpOverClass. Also suppose that the operator function operator++ is a member of the classOpOverClass. 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

}

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

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

className operator++();

Function Definition:

className className::operator++()

{

//increment the value of the object by 1

return *this;

}

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

OpOverClass operator++(OpOverClass& incObj)

{

//increment the object

(incObj.a)++;

(incObj.b)++;

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

}

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

Function Prototype:

friend className operator++(className&);

Function Definition:

className operator++(className& incObj)

{

//increment incObj by 1

return incObj;

}

slide70
Overloading the Post-increment Operator
  • Overload the post-increment operator for the classOpOverClass.
  • 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 classOpOverClass is

OpOverClass operator++(int);

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

slide72
The function definition of the post-increment operator for the classOpOverClass 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

}

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

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

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

Function Definition:

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

{

className temp = incObj; //copy incObj into temp

//increment incObj

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

}

slide74
//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

slide75
//overload the relational operators

booloperator==(const OpOverClass&) const;

booloperator!=(const OpOverClass&) const;

booloperator<=(const OpOverClass&) const;

booloperator<(const OpOverClass&) const;

booloperator>=(const OpOverClass&) const;

booloperator>(const OpOverClass&) const;

//constructors

OpOverClass();

OpOverClass(int i, int j);

//include other functions as needed

private:

int a;

int b;

};

slide76
//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);

slide77
//overload the relational operators

friendbooloperator==(const OpOverClass&,

const OpOverClass&);

friendbooloperator!=(const OpOverClass&,

const OpOverClass&);

friendbooloperator<=(const OpOverClass&,

const OpOverClass&);

friendbooloperator<(const OpOverClass&,

const OpOverClass&);

friendbooloperator>=(const OpOverClass&,

const OpOverClass&);

friendbooloperator>(const OpOverClass&,

const OpOverClass&);

public:

//constructors

OpOverClass();

OpOverClass(int i, int j);

//include other functions as needed

private:

int a;

int b;

};

slide78
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.
slide79
Classes and Pointer Data Members (Revisited)

1. Explicitly overload the assignment operator

2. Include the copy constructor

3. Include the destructor

  • Operator Overloading: One Final Word
slide80
PROGRAMMING EXAMPLE: CLOCKTYPE
  • Chapter 13 defined a classclockType 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 classclockType.
  • 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 classclockType requires the user to input the time in the form hr:min:sec.
slide81
//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

slide82
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

};

slide83
//overload the preincrement operator

clockType 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

}

slide84
//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));

}

slide85
//constructor with parameters

clockType::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;

}

slide86
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;

}

slide87
void clockType::getTime(int& hours, int& minutes,

int& seconds)

{

hours = hr;

minutes = min;

seconds = sec;

}

slide88
The time must be output in the form

hh:mm:ss

//overload the stream insertion operator

ostream& 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

}

slide89
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

}

slide90
//Program that uses the class clockType

#include <iostream>

#include "newClock.h"

using namespace std;

int main()

{

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

clockType yourClock; //Line 2

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

cout<<"Line 4: yourClock = "<<yourClock<<endl;

//Line 4

cout<<"Line 5: Enter time in the form "

<<"hr:min:sec "; //Line 5

cin>>myClock; //Line 6

cout<<"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

slide91
yourClock.setTime(13,35,38); //Line 10

cout<<"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 13

else//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;

}

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

Line 3: myClock = 05:06:23

Line 4: yourClock = 00:00:00

Line 5: Enter the time in the form hr:min:sec 4:50:59

Line 7: The new time of myClock = 04:50:59

Line 9: After increment the time, myClock = 04:51:00

Line 11: After setting the time, yourClock = 13:35:38

Line 15: The times of myClock and yourClock are not equal

Line 17: The time of myClock is less than or equal to

the time of yourClock

slide93
PROGRAMMING EXAMPLE: COMPLEX NUMBERS

A number of the form a + ib, where i2 = -1, andaandbare 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)

slide94
//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(constdouble& real,

constdouble& imag);

complexType(double real = 0, double imag = 0);

complexType operator+(const complexType&

otherComplex) const;

complexType operator*(const complexType&

otherComplex) const;

booloperator==(const complexType& otherComplex) const;

private:

double realPart;

double imaginaryPart;

};

#endif

slide95
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

}

slide96
Now the input is of the form, say

(3, 5)

istream& operator>> (istream& isObject,

complexType& complex)

{

char ch;

isObject>>ch; //Step a

isObject>>complex.realPart; //Step b

isObject>>ch; //Step c

isObject>>complex.imaginaryPart; //Step d

isObject>>ch; //Step e

return isObject; //Return the istream object

}

slide97
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(constdouble& real,

constdouble& imag)

{

realPart = real;

imaginaryPart = imag;

}

slide98
//overload the operator +

complexType complexType::operator+

(const complexType& otherComplex) const

{

complexType temp;

temp.realPart = realPart + otherComplex.realPart;

temp.imaginaryPart = imaginaryPart

+ otherComplex.imaginaryPart;

return temp;

}

slide99
//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;

}

slide100
//Program that uses the class complexType

#include <iostream>

#include "complexType.h"

using namespace std;

int main()

{

complexType num1(23,34); //Line 1

complexType num2; //Line 2

complexType num3; //Line 3

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

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

cout<<"Line 6: Enter the complex number "

<<"in the form (a,b) "; //Line 6

cin>>num2; //Line 7

cout<<endl; //Line 8

slide101
cout<<"Line 9: New value of num2 = "

<<num2<<endl; //Line 9

num3 = num1 + num2; //Line 10

cout<<"Line 11: Num3 = "<<num3<<endl; //Line 11

cout<<"Line 12: "<<num1<<" + "<<num2

<<" = "<<num1 + num2<<endl; //Line 12

cout<<"Line 13: "<<num1<<" * "<<num2

<<" = "<<num1 * num2<<endl; //Line 13

return 0;

}

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

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)

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

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

slide105
//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

}

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

slide107
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, and

4. 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.
slide108
//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(constchar *);

//constructor; conversion from the char string

newString();

//default constructor to initialize the string to null

newString(const newString&);

//copy constructor

slide109
~newString();

//destructor

char &operator[] (int);

constchar &operator[](int) const;

//overload the relational operators

booloperator==(const newString&) const;

booloperator!=(const newString&) const;

booloperator<=(const newString&) const;

booloperator<(const newString&) const;

booloperator>=(const newString&) const;

booloperator>(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

slide110
//Implementation file myString.cpp

#include <iostream>

#include <iomanip>

#include <cstring>

#include <cassert>

#include "myString.h"

using namespace std;

slide111
//constructor: conversion from the char string to newString

newString::newString(constchar *str)

{

strLength = strlen(str);

strPtr = newchar[strLength+1]; //allocate

//memory to storethe char string

assert(strPtr != NULL);

strcpy(strPtr,str); //copy string into strPtr

}

//default constructor to store the null string

newString::newString()

{

strLength = 1;

strPtr = newchar[1];

assert(strPtr != NULL);

strcpy(strPtr,"");

}

slide112
//copy constructor

newString::newString(const newString& rightStr)

{

strLength = rightStr.strLength;

strPtr = newchar[strLength + 1];

assert(strPtr != NULL);

strcpy(strPtr, rightStr.strPtr);

}

newString::~newString() //destructor

{

delete [] strPtr;

}

slide113
//overload the assignment operator

const newString& newString::operator=

(const newString& rightStr)

{

if(this != &rightStr) //avoid self-copy

{

delete [] strPtr;

strLength = rightStr.strLength;

strPtr = newchar[strLength + 1];

assert(strPtr != NULL);

strcpy(strPtr, rightStr.strPtr);

}

return *this;

}

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

{

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

return strPtr[index];

}

slide114
constchar& newString::operator[](int index) const

{

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

return strPtr[index];

}

//overload the relational operators

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);

}

slide115
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);

}

slide116
//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;

}

slide117
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.
slide118
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.

slide119
//Test Program

#include <iostream>

#include <cstring>

#include "myString.h"

using namespace std;

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 2

cout<<"Line 3: "<<s1<<" is less than "<<s2

<<endl; //Line 3

else //Line 4

cout<<"Line 5: "<<s2<<" is less than "<<s1

<<endl; //Line 5

slide120
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;

}

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

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

slide122
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);

slide123
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.
slide124
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.
slide125
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.

slide126
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.
slide127
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 1

cout<<"Line 2: Larger of A and B = "

<<larger('A','B')<<endl; //Line 2

cout<<"Line 3: Larger of 5.6 and 3.2 = "

<<larger(5.6,3.2)<<endl; //Line 3

newString str1 = "Hello"; //Line 4

newString str2 = "Happy"; //Line 5

cout<<"Line 6: Larger of "<<str1<<" and "

<<str2<<" = "<<larger(str1, str2)

<<endl; //Line 6

return 0;

}

slide128
template<class Type>

Type larger(Type x, Type y)

{

if(x >= y)

return x;

else

return y;

}

Output

Line 1: Larger of 5 and 6 = 6

Line 2: Larger of A and B = B

Line 3: Larger of 5.6 and 3.2 = 5.6

Line 6: Larger of Hello and Happy = Hello

slide129
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.
slide130
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

};

slide131
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.
slide132
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.
slide133
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.
slide134
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.
slide135
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();

slide136
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);

}

slide137
template<class elemType>

int listType<elemType>::getLength()

{

return length;

}

template<class elemType>

int listType<elemType>::getMaxSize()

{

return maxSize;

}

//constructor; the default array size is 50

template<class elemType>

listType<elemType>::listType(int listSize)

{

maxSize = listSize;

length = 0;

list = new elemType[maxSize];

}

slide138
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

slide139
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

slide140
//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 8

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

}

slide141
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 22

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

}

cout<<endl; //Line 24

cout<<"Line 25: The list you entered is: "

<<endl; //Line 25

slide142
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

slide143
for(counter = 0; counter < intListSize;

counter++) //Line 38

{

cin>>number; //Line 39

intList2.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;

}

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

List 5: Processing the integer List

List 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 List

Line 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: 10

Line 36: Processing the integer List

Line 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 = 10

Line 50: Maximum size of the list = 10