C++ Functions

Agenda
 What is a function?  Sharing data among
 Types of C++ functions through
functions: function parameters
 Standard functions  Value parameters
 User-defined functions  Reference parameters
 C++ function structure
 Const reference
parameters
 Function signature
 Function body
 Scope of variables
 Local Variables
 Declaring and  Global variable
Implementing C++
functions
2
 Functions and subprograms
 The Top-down design appeoach is based on dividing the
main problem into smaller tasks which may be divided
into simpler tasks, then implementing each simple task
by a subprogram or a function
 A C++ function or a subprogram is simply a chunk of C+
+ code that has
 A descriptive function name, e.g.
 computeTaxes to compute the taxes for an employee
 isPrime to check whether or not a number is a prime number
 A returning value
 The computeTaxes function may return with a double number
representing the amount of taxes
 The isPrime function may return with a Boolean value (true or false)

3
 C++ Standard Functions
 C++ language is shipped with a lot of functions
which are known as standard functions
 These standard functions are groups in different
libraries which can be included in the C++
program, e.g.
 Math functions are declared in <math.h> library
 Character-manipulation functions are declared in
<ctype.h> library
 C++ is shipped with more than 100 standard libraries,
some of them are very popular such as <iostream.h>
and <stdlib.h>, others are very specific to certain
hardware platform, e.g. <limits.h> and <largeInt.h>

4
 Example of Using
Standard C++ Math Functions
#include <iostream.h>
#include <math.h>
void main()
{
// Getting a double value
double x;
cout << "Please enter a real number: ";
cin >> x;
// Compute the ceiling and the floor of the real number
cout << "The ceil(" << x << ") = " << ceil(x) << endl;
cout << "The floor(" << x << ") = " << floor(x) << endl;
}

5
 Example of Using
Standard C++ Character Functions
#include <iostream.h> // input/output handling
#include <ctype.h> // character type functions
void main()
{ Explicit casting
char ch;
cout << "Enter a character: ";
cin >> ch;
cout << "The toupper(" << ch << ") = " << (char) toupper(ch) << endl;
cout << "The tolower(" << ch << ") = " << (char) tolower(ch) << endl;
if (isdigit(ch))
cout << "'" << ch <<"' is a digit!\n";
else
cout << "'" << ch <<"' is NOT a digit!\n";
}

6
 User-Defined C++ Functions
 Although C++ is shipped with a lot of standard
functions, these functions are not enough for all
users, therefore, C++ provides its users with a
way to define their own functions (or user-
defined function)
 For example, the <math.h> library does not
include a standard function that allows users to
round a real number to the ith digits, therefore,
we must declare and implement this function
ourselves
7
How to define a C++ Function?
 Generally speaking, we define a C++
function in two steps (preferably but not
mandatory)
 Step #1 – declare the function signature in
either a header file (.h file) or before the main
function of the program
 Step #2 – Implement the function in either an
implementation file (.cpp) or after the main
function

8
What is The Syntactic Structure of
a C++ Function?
 A C++ function consists of two parts
 The function header, and
 The function body

 The function header has the following

syntax
<return value> <name> (<parameter list>)
 The function body is simply a C++ code
enclosed between { }
9
 Example of User-defined
C++ Function

double computeTax(double income)

{
if (income < 5000.0) return 0.0;
double taxes = 0.07 * (income-5000.0);
return taxes;
}
10
 Example of User-defined
C++ Function
Function
header

double computeTax(double income)

{
if (income < 5000.0) return 0.0;
double taxes = 0.07 * (income-5000.0);
return taxes;
}
11
 Example of User-defined
C++ Function
Function header Function body

double computeTax(double income)

{
if (income < 5000.0) return 0.0;
double taxes = 0.07 * (income-5000.0);
return taxes;
}
12
 Function Signature
 The function signature is actually similar to
the function header except in two aspects:
 The parameters’ names may not be specified
in the function signature
 The function signature must be ended by a
semicolon
Unnamed Semicolon
 Example Parameter ;

double computeTaxes(double) ;

13
 Why Do We Need Function
Signature?
 For Information Hiding
 If you want to create your own library and share it with
your customers without letting them know the
implementation details, you should declare all the
function signatures in a header (.h) file and distribute
the binary code of the implementation file
 For Function Abstraction
 By only sharing the function signatures, we have the
liberty to change the implementation details from time
to time to
 Improve function performance
 make the customers focus on the purpose of the function, not
its implementation

14
 Example
double computeTaxes(double income)
#include <iostream>
{
#include <string>
if (income<5000) return 0.0;
using namespace std;
return 0.07*(income-5000.0);
}
// Function Signature
double getIncome(string);
double getIncome(string prompt)
double computeTaxes(double);
{
void printTaxes(double);
cout << prompt;
double income;
void main()
cin >> income;
{
return income;
// Get the income;
}
double income = getIncome("Please enter
the employee income: ");
void printTaxes(double taxes)
// Compute Taxes {
double taxes = computeTaxes(income); cout << "The taxes is $" << taxes << endl;
}
// Print employee taxes
printTaxes(taxes);
}

15
 Building Your Libraries
 It is a good practice to build libraries to be
used by you and your customers
 In order to build C++ libraries, you should
be familiar with
 How to create header files to store function
signatures
 How to create implementation files to store
function implementations
 How to include the header file to your
program to use your user-defined functions
16
 C++ Header Files
 The C++ header files must have .h
extension and should have the following
structure
 #ifndef compiler directive
 #define compiler directive
 May include some other header files
 All functions signatures with some comments
about their purposes, their inputs, and outputs
 #endif compiler directive

17
 TaxesRules Header file
#ifndef _TAXES_RULES_ double computeTaxes(double);
#define _TAXES_RULES_ // purpose -- to compute the taxes for
a given income
#include <iostream> // input -- a double value
representing the income
#include <string>
using namespace std; // output -- a double value
representing the taxes
double getIncome(string); void printTaxes(double);
// purpose -- to get the employee // purpose -- to display taxes to the
income user
// input -- a string prompt to be // input -- a double value
displayed to the user representing the taxes
// output -- a double value // output -- None
representing the income
#endif

18
TaxesRules Implementation File
#include "TaxesRules.h"

double computeTaxes(double
income) void printTaxes(double taxes)
{ {
if (income<5000) return 0.0; cout << "The taxes is $" << taxes
return 0.07*(income-5000.0); << endl;
} }

double getIncome(string prompt)

{
cout << prompt;
double income;
cin >> income;
return income;
}

19
 Main Program File
#include "TaxesRules.h"
void main()
{
// Get the income;
double income =
getIncome("Please enter the employee income: ");

// Compute Taxes
double taxes = computeTaxes(income);

// Print employee taxes

printTaxes(taxes);
}

20
 Inline Functions
 Sometimes, we use the keyword inline to define
user-defined functions
 Inline functions are very small functions, generally,
one or two lines of code
 Inline functions are very fast functions compared to
the functions declared without the inline keyword
 Example
inline double degrees( double radian)
{
return radian * 180.0 / 3.1415;
}

21
 Example #1
 Write a function to test if a number is an
odd number

inline bool odd (int x)

{
return (x % 2 == 1);
}

22
 Example #2
 Write a function to compute the distance
between two points (x1, y1) and (x2, y2)

Inline double distance (double x1, double y1,

double x2, double y2)
{
return sqrt(pow(x1-x2,2)+pow(y1-y2,2));
}

23
 Example #3
 Write a function to compute n!

int factorial( int n)

{
int product=1;
for (int i=1; i<=n; i++) product *= i;
return product;
}

24
 Example #4
Function Overloading
 Write functions to return with the maximum number of
two numbers
An overloaded
function is a
inline int max( int x, int y) function that is
{ defined more than
once with different
if (x>y) return x; else return y; data types or
} different number of
parameters
inline double max( double x, double y)
{
if (x>y) return x; else return y;
}

25
 Sharing Data Among
User-Defined Functions
 There
are two ways to share data
among different functions
 Using global variables (very bad practice!)
 Passing data through function parameters
 Value parameters
 Reference parameters
 Constant reference parameters

26
 C++ Variables
 A variable is a place in memory that has
 A name or identifier (e.g. income, taxes, etc.)
 A data type (e.g. int, double, char, etc.)
 A size (number of bytes)
 A scope (the part of the program code that can use it)
 Global variables – all functions can see it and using it
 Local variables – only the function that declare local
variables see and use these variables
 A life time (the duration of its existence)
 Global variables can live as long as the program is executed
 Local variables are lived only when the functions that define
these variables are executed

27
 I. Using Global Variables
#include <iostream.h>
int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void main()
{
f2();
cout << x << endl;
}

28
 I. Using Global Variables
#include <iostream.h> x 0

int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void main()
{
f2();
cout << x << endl;
}

29
 I. Using Global Variables
#include <iostream.h> x 0

int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void main()
{
f2();
cout << x << endl; void main()
{
} 1 f2();
cout << x << endl ;
}
30
 I. Using Global Variables
#include <iostream.h> x 0
4

int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void f2()
void main() {
{ 2 x += 4;
f1();
f2(); }

cout << x << endl; void main()

{
} 1 f2();
cout << x << endl ;
}
31
 I. Using Global Variables
#include <iostream.h> x 5
4

int x = 0; void f1()

{
void f1() { x++; } 4 x++;
}
void f2() { x+=4; f1(); }
void f2()
void main() {
{ 3
x += 4;
f1();
f2(); }

cout << x << endl; void main()

{
} 1 f2();
cout << x << endl ;
}
32
 I. Using Global Variables
#include <iostream.h> x 5
4

int x = 0; void f1()

{
void f1() { x++; } x++;
5 }
void f2() { x+=4; f1(); }
void f2()
void main() {
{ 3
x += 4;
f1();
f2(); }

cout << x << endl; void main()

{
} 1 f2();
cout << x << endl;
}
33
 I. Using Global Variables
#include <iostream.h> x 5
4

int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void f2()
void main() {
{ x += 4;
f1();
f2(); 6 }

cout << x << endl; void main()

{
} 1 f2();
cout << x << endl;
}
34
 I. Using Global Variables
#include <iostream.h> x 5
4

int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void main()
{
f2();
cout << x << endl; void main()
{
} f2();
7 cout << x << endl;
}
35
 I. Using Global Variables
#include <iostream.h> x 5
4

int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void main()
{
f2();
cout << x << endl; void main()
{
} f2();
cout << x << endl;
8 }
36
 I. Using Global Variables
#include <iostream.h>
int x = 0;
void f1() { x++; }
void f2() { x+=4; f1(); }
void main()
{
f2();
cout << x << endl;
}

37
 What Happens When We Use
Inline Keyword?
#include <iostream.h>
int x = 0;
Inline void f1() { x++; }
Inline void f2() { x+=4; f1();}
void main()
{
f2();
cout << x << endl;
}
38
 What Happens When We Use
Inline Keyword?
#include <iostream.h> x 0

int x = 0;
The inline keyword
Inline void f1() { x++; } instructs the compiler to
Inline void f2() { x+=4; f1();} replace the function call
with the function body!
void main()
{
f2(); void main()
{
cout << x << endl; 1 x+=4;
x++;
} cout << x << endl;
}
39
 What Happens When We Use
Inline Keyword?
#include <iostream.h> x 4

int x = 0;
Inline void f1() { x++; }
Inline void f2() { x+=4; f1();}
void main()
{
f2(); void main()
{
cout << x << endl; x+=4;
2 x++;
} cout << x << endl;
}
40
 What Happens When We Use
Inline Keyword?
#include <iostream.h> x 5

int x = 0;
Inline void f1() { x++; }
Inline void f2() { x+=4; f1();}
void main()
{
f2(); void main()
{
cout << x << endl; x+=4;
x++;
} 3 cout << x << endl;
}
41
 What Happens When We Use
Inline Keyword?
#include <iostream.h> x 5

int x = 0;
Inline void f1() { x++; }
Inline void f2() { x+=4; f1();}
void main()
{
f2(); void main()
{
cout << x << endl; x+=4;
x++;
} cout << x << endl;
4 }
42
 What Happens When We Use
Inline Keyword?
#include <iostream.h>
int x = 0;
Inline void f1() { x++; }
Inline void f2() { x+=4; f1();}
void main()
{
f2();
cout << x << endl;
}
43
 What is Bad About Using
Global Vairables?
 Not safe!
 If two or more programmers are working together in a
program, one of them may change the value stored in
the global variable without telling the others who may
depend in their calculation on the old stored value!
 Against The Principle of Information Hiding!
 Exposing the global variables to all functions is
against the principle of information hiding since this
gives all functions the freedom to change the values
stored in the global variables at any time (unsafe!)

44
 Local Variables
 Local variables are declared inside the function
body and exist as long as the function is running
and destroyed when the function exit
 You have to initialize the local variable before
using it
 If a function defines a local variable and there
was a global variable with the same name, the
function uses its local variable instead of using
the global variable

45
 Example of Defining and Using
Global and Local Variables
#include <iostream.h>
int x; // Global variable
Void fun(); // function signature

void main()
{
x = 4;
fun();
cout << x << endl;
}

void fun()
{
int x = 10; // Local variable
cout << x << endl;
}
46
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 0
int x; // Global variable
Void fun(); // function signature Global variables are
automatically initialized to 0
void main()
{
x = 4;
fun();
cout << x << endl;
}

void fun()
{
int x = 10; // Local variable
cout << x << endl;
}
47
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 0
int x; // Global variable
Void fun(); // function signature

void main()
{
x = 4;
fun();
cout << x << endl;
}

void fun() void main()

{ {
int x = 10; // Local variable 1 x = 4;
fun();
cout << x << endl;
cout << x << endl;
} }
48
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 4
int x; // Global variable
Void fun(); // function signature

void main() void fun()

{
x ????
x = 4;
fun(); {
3 int x = 10;
cout << x << endl;
cout << x << endl;
} }

void fun() void main()

{ {
int x = 10; // Local variable x = 4;
2 fun();
cout << x << endl;
cout << x << endl;
} }
49
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 4
int x; // Global variable
Void fun(); // function signature

void main() void fun()

{
x 10
x = 4;
fun(); {
3 int x = 10;
cout << x << endl;
cout << x << endl;
} }

void fun() void main()

{ {
int x = 10; // Local variable x = 4;
2 fun();
cout << x << endl;
cout << x << endl;
} }
50
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 4
int x; // Global variable
Void fun(); // function signature

void main()
void fun()
{
x = 4; x 10
fun();
{
cout << x << endl;
int x = 10;
}
4 cout << x << endl;
}
void fun()
{ void main()
int x = 10; // Local variable {
cout << x << endl; x = 4;
} 2 fun();
cout << x << endl;
51 }
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 4
int x; // Global variable
Void fun(); // function signature

void main()
void fun()
{
x = 4; x 10
fun();
{
cout << x << endl;
int x = 10;
}
cout << x << endl;
5 }
void fun()
{ void main()
int x = 10; // Local variable {
cout << x << endl; x = 4;
} 2 fun();
cout << x << endl;
52 }
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 4
int x; // Global variable
Void fun(); // function signature

void main()
{
x = 4;
fun();
cout << x << endl;
}

void fun()
{ void main()
int x = 10; // Local variable {
cout << x << endl; x = 4;
} fun();
6 cout << x << endl;
53 }
 Example of Defining and Using
Global and Local Variables
#include <iostream.h> x 4
int x; // Global variable
Void fun(); // function signature

void main()
{
x = 4;
fun();
cout << x << endl;
}

void fun()
{ void main()
int x = 10; // Local variable {
cout << x << endl; x = 4;
} fun();
cout << x << endl;
54 7 }
 II. Using Parameters
 Function Parameters come in three
flavors:
 Value parameters – which copy the values of
the function arguments
 Reference parameters – which refer to the
function arguments by other local names and
have the ability to change the values of the
referenced arguments
 Constant reference parameters – similar to
the reference parameters but cannot change
the values of the referenced arguments
55
 Value Parameters
 This is what we use to declare in the function signature or
function header, e.g.
int max (int x, int y);
 Here, parameters x and y are value parameters
 When you call the max function as max(4, 7), the values 4 and 7
are copied to x and y respectively
 When you call the max function as max (a, b), where a=40 and
b=10, the values 40 and 10 are copied to x and y respectively
 When you call the max function as max( a+b, b/2), the values 50
and 5 are copies to x and y respectively
 Once the value parameters accepted copies of the
corresponding arguments data, they act as local
variables!

56
 Example of Using Value
Parameters and Global Variables
#include <iostream.h> x 0
int x; // Global variable
void fun(int x)
{
cout << x << endl;
x=x+5;
}
void main()
{
x = 4; void main()
fun(x/2+1); {
1 x = 4;
cout << x << endl; fun(x/2+1);
} cout << x << endl;
57 }
 Example of Using Value
Parameters and Global Variables
#include <iostream.h> x 4
int x; // Global variable
void fun(int x)
{
cout << x << endl;
x=x+5; void fun(int x )
{
} 3 cout << x << endl;
void main() x=x+5;
{ }
x = 4;
void main()
fun(x/2+1); {
cout << x << endl; x = 4; 3
} 2 fun(x/2+1);
cout << x << endl;
58 }
 Example of Using Value
Parameters and Global Variables
#include <iostream.h> x 4
int x; // Global variable
void fun(int x)
{
cout << x << endl;
x=x+5; void fun(int x 8
3 )
{
} cout << x << endl;
void main() 4 x=x+5;
{ }
x = 4;
void main()
fun(x/2+1); {
cout << x << endl; x = 4;
} 2 fun(x/2+1);
cout << x << endl;
59 }
 Example of Using Value
Parameters and Global Variables
#include <iostream.h> x 4
int x; // Global variable
void fun(int x)
{
cout << x << endl;
x=x+5; void fun(int x 3
8 )
{
} cout << x << endl;
void main() x=x+5;
{ 5 }
x = 4;
void main()
fun(x/2+1); {
cout << x << endl; x = 4;
} 2 fun(x/2+1);
cout << x << endl;
60 }
 Example of Using Value
Parameters and Global Variables
#include <iostream.h> x 4
int x; // Global variable
void fun(int x)
{
cout << x << endl;
x=x+5;
}
void main()
{
x = 4;
void main()
fun(x/2+1); {
cout << x << endl; x = 4;
} fun(x/2+1);
6 cout << x << endl;
61 }
 Example of Using Value
Parameters and Global Variables
#include <iostream.h> x 4
int x; // Global variable
void fun(int x)
{
cout << x << endl;
x=x+5;
}
void main()
{
x = 4;
void main()
fun(x/2+1); {
cout << x << endl; x = 4;
} fun(x/2+1);
cout << x << endl;
62 7 }
 Reference Parameters
 As we saw in the last example, any changes in
the value parameters don’t affect the original
function arguments
 Sometimes, we want to change the values of the
original function arguments or return with more
than one value from the function, in this case we
use reference parameters
 A reference parameter is just another name to the
original argument variable
 We define a reference parameter by adding the & in
front of the parameter name, e.g.
double update (double & x);
63
 Example of Reference Parameters
#include <iostream.h>
void fun(int &y)
{
cout << y << endl;
y=y+5;
}
void main()
{
int x = 4; // Local variable void main()
fun(x); {
cout << x << endl; 1 int x = 4; ?
4 x
fun(x);
} cout << x << endl;
}
64
 Example of Reference Parameters
#include <iostream.h>
void fun(int &y)
{
cout << y << endl;
void fun( int & y )
y=y+5; {
} 3 cout<<y<<endl;
void main() y=y+5;
}
{
int x = 4; // Local variable void main()
fun(x); {
cout << x << endl; int x = 4; ?
4 x
2 fun(x);
} cout << x << endl;
}
65
 Example of Reference Parameters
#include <iostream.h>
void fun(int &y)
{
cout << y << endl;
void fun( int & y )
y=y+5; {
} cout<<y<<endl;
void main() 4 y=y+5;
9
}
{
int x = 4; // Local variable void main()
fun(x); {
cout << x << endl; int x = 4; ?
4 x
2 fun(x);
} cout << x << endl;
}
66
 Example of Reference Parameters
#include <iostream.h>
void fun(int &y)
{
cout << y << endl;
void fun( int & y )
y=y+5; {
} cout<<y<<endl;
void main() y=y+5;
5 }
{
int x = 4; // Local variable void main()
fun(x); {
cout << x << endl; int x = 4; ?
9 x
2 fun(x);
} cout << x << endl;
}
67
 Example of Reference Parameters
#include <iostream.h>
void fun(int &y)
{
cout << y << endl;
y=y+5;
}
void main()
{
int x = 4; // Local variable void main()
fun(x); {
cout << x << endl; int x = 4; ?
9 x
fun(x);
} 6 cout << x << endl;
}
68
 Example of Reference Parameters
#include <iostream.h>
void fun(int &y)
{
cout << y << endl;
y=y+5;
}
void main()
{
int x = 4; // Local variable void main()
fun(x); {
cout << x << endl; int x = 4; ?
9 x
fun(x);
} cout << x << endl;
7 }
69
Constant Reference Parameters
 Constant reference parameters are used under
the following two conditions:
 The passed data are so big and you want to save
time and computer memory
 The passed data will not be changed or updated in
the function body
 For example
void report (const string & prompt);
 The only valid arguments accepted by reference
parameters and constant reference parameters
are variable names
 It is a syntax error to pass constant values or
expressions to the (const) reference parameters
70
Finding the Maximum of Two
Integers
 Here’s a small function that you might write to
find the maximum of two integers.
int maximum(int a, int b)
{
if (a > b)
return a;
else
return b;
}
Finding the Maximum of Two
Doubles
 Here’s a small function that you might write to
find the maximum of two double numbers.
int maximum(double a, double b)
{
if (a > b)
return a;
else
return b;
}
Finding the Maximum of Two Knafns

 Here’s a small function that you might write to

find the maximum of two knafns.
int maximum(knafn a, knafn b)
{
if (a > b)
return a;
else
return b;
}
 One Hundred Million Functions...

 Suppose your program uses 100,000,000

different data types, and you need a maximum
function for each...
int maximum(Hoo a, Hoo b) int maximum(Noo a, Noo b)
{
int maximum(Hoo a, Hoo b)
{
if (a > b)
int maximum(Moo a,int
{ {
int maximum(Noo a, Noo b)
int maximum(Hoo
maximum(Doo
Moo b)
{
a, Doo b) a, Hoo b)
int maximum(Moo a,int maximum(Doo
Moo b) a, Doo b)
{
int maximum(Moo int
a, maximum(Doo
Moo b)
return
a, Dooa;b) if (a > b) if (a > b) if (a > b) { {
if (a > b) {
int maximum(Noo a, Noo b) if (a > b)
{ { else
return a; return a; return a; if (a > b) if (a > b)
{ return a; return a; if (a > b) return intb; maximum(Foo a, Foo b)if (a > b) else else
return a; return a;
if (a > b)else else return a;
if (a > b) else
return a; return}a; { returnelse b; return b; return int b; maximum(Foo a, Foo b)
else else
return a; return int b; maximum(Foo a, Foo b) return b; else if (a > b) } } } { return b;
else } return b; return b;
else } { return b; return a; if (a > b) } }
return b; return b; }
if (a > b) } } else return a;
} return a; return b; else
else int maximum(Poo a, Poo b) } return b;
int maximum(Boo
int maximum(Poo a, Boo
a, Poo b) b) }
return b; { int maximum(Boo a, Boo b)
int maximum(Koo a, Koo b) { {
int maximum(Poo a, Poo b) } if (a > b) {
{
int maximum(Boo {a, Boo b)
return a; if (a if> (a
b)> b) int maximum(Koo a, Koo b)
int maximum(Joo a, Joo b) return if (a > b)
if (a > b) int maximum(Koo a, Koo b) {
else if (a > b) return a; a; { int maximum(Joo a, Joo b)
{ int maximum(Ioo a, Ioo b) return a;
return a; { int maximum(Joo a, Joo b)
if (a >b;b)
int maximum(Knafn
return a, Knafnreturn
b) a; else else if (a > b)
{
return a; if (a > b) int maximum(Knafnreturn b; a, Knafn b)int maximum(Ioo a, Ioo b) else
else if (a > b) { } else { return b; return a;
{ int maximum(Ioo a, Ioo b) return a; if (a > b) return b;
int maximum(Knafn
return b; a, Knafnreturn
b) a; if (a >else
b) returnifb; (a > b) {} } else {
if (a > b) return b; else return a; }
{} else { return a; } return a; if (a > b) return if (a
b; > b)
return a; return b; else
if (a > b) returnifb; (a > b) else} else return a; } return a;
return b;
else } else else
return a; } return a; return b; return b;
return b; int maximum(Coo a, Coo b) }
else else } } return b; return b;
} { int maximum(Coo a, Coo b)
return b; return b; } }
int maximum(Coo a, Coo b) if (a > b) int maximum(Goo a, Goo b) {
} } int maximum(Loo a, Loo b) if (a > b) int maximum(Goo a, Goo b)
{ return a; { int maximum(Loo a, Loo b)
{ return a; {
if (a > b) int maximum(Goo a, Goo b) else if (a > b) {
int maximum(Loo a, Loo b) if (a > b) else if (a > b)
return a; { return b; return a; if (a > b)
{ return a; return b; return a;
else if (a > b) else } else return a;
if (a > b) } else
return b; return a; return b; return b; else
return a; return b;
} else } return b;
else } }
return b; }
return b;
}
}
A Template Function for Maximum

 This template function can be used with many

data types.
template <class Item>
Item maximum(Item a, Item b)
{
if (a > b)
return a;
else
return b;
}
A Template Function for Maximum

When you write a template function, you

choose a data type for the function to depend
upon...
template <class Item>
Item maximum(Item a, Item b)
{
if (a > b)
return a;
else
return b;
}
A Template Function for Maximum

 A template prefix is also needed immediately

before the function’s implementation:
template <class Item>
Item maximum(Item a, Item b)
{
if (a > b)
return a;
else
return b;
}
Using a Template Function

 Once a template function is defined, it may be

used with any adequate data type in your
program...
template <class Item>
Item maximum(Item a, Item b) cout << maximum(1,2);
{ cout << maximum(1.3, 0.9);
if (a > b) ...
return a;
else
return b;
}
Finding the Maximum Item in an
Array
 Here’s another function that can be made
more general by changing it to a template
function:
int array_max(int data[ ], size_t n)
{
size_t i;
int answer;

assert(n > 0);

answer = data[0];
for (i = 1; i < n; i++)
if (data[i] > answer) answer = data[i];
return answer;
}
Finding the Maximum Item in an
Array
 Here’s the template function:

template <class Item>

Item array_max(Item data[ ], size_t n)
{
size_t i;
Item answer;

assert(n > 0);

answer = data[0];
for (i = 1; i < n; i++)
if (data[i] > answer) answer = data[i];
return answer;
}
 Function Overloading
 C++ enables several functions of the same name to be
defined, as long as they have different signatures.
 This is called function overloading.
 The C++ compiler selects the proper function to call by
examining the number, types and order of the
arguments in the call.
 Overloaded functions are distinguished by their signatures

 Signature - Combination of a function’s name and its

parameter types (in order)

 C++ compilers encodes each function identifier with the

number and types of its parameters (sometimes referred to

as name mangling or name decoration) to enable type-safe

linkage.
 Signature of a Function
 A function’s argument list (i.e., number and
type of argument) is known as the function’s
signature.
 Functions with Same signature - Two
functions with same number and types of
arguments in same order
 variable names doesn’t matter. For instance,
following two functions have same signature.
void squar (int a, float b); //function 1
void squar (int x, float y);
84
Following code fragment overloads a function
name prnsqr( ).

void prnsqr (int i); //overloaded for integer #1

void prnsqr (char c); //overloaded for character #2

void prnsqr (float f); //overloaded for floats #3

void prnsqr (double d); //overloaded for double floats #4

85 85
void prnsqr (int i)
{
cout<<“Integer”<<i<<“’s square is”<<i*i<<“\n”;
}
void prnsqr (char c);
{
cout <<“No Square for characters”<<“\n”;
}
void prnsqr (float f)
{
cout<<“float”<<f <<“’s square is”<<f *f<<“\n”;
}
void prnsqr (double d)
{
cout <<“Double float”<<d<<“’s square is”<<d*d<<“\n’;
}
86 86
 Resolution by Compiler when it sees second
function with same name
1) Signature of subsequent functions match previous function’s,
then the second is treated as a re-declaration of the first - Error
2) Signatures of two functions match exactly but the return type
differ, then the second declaration is treated as an erroneous
re-declaration of the first
For example,
float square (float f);
double square (float x);
//error
// Differ only by return type so erroneous re-
declaration
87 87
3) If the signature of the two functions differ in
either the number or type of their arguments,
the two functions are considered to be
overloaded.

88 88
 CALLING OVERLOADED FUNCTIONS

Overloaded functions are called just like other

functions. The number and type of arguments
determine which function should be invoked.
For instance consider the following code fragment:
prnsqr (‘z’);
prnsqr (13);
prnsqr (134.520000012);
prnsqr (12.5F);

89 89
 Steps Involved in Finding the Best
Match for a function call
A call to an overloaded function is resolved to a particular
instance of the function, there are three possible cases,
a function call may result in:

a) One match - A match is found for the function call.

b) No match - No match is found for the function call.

c) Ambiguous Match - More than one defined

instance for the function call.

90 90
 1. Exact Match
For example, there are two functions with same name
afunc:
void afunc(int);
void afunc(double);
//overloaded functions
The function call
afunc(0);
//exactly match. Matches afunc(int)
is matched to void afunc(int); and compiler invokes
corresponding function definition
as 0 (zero) is of type int
91 91
2. A match through promotion
If no exact match is found, an attempt is made to
achieve a match through promotion of the actual
argument.

Recall that the conversion of integer types (char,

short, enumerator, int) into int - integral
promotion.

92 92
For example, consider the following code
fragment:

void afunc (int);

void afunc (float);

//match through the promotion;
afunc (‘c’); matches afunc (int)
Will invoke afunc(int)

93 93
Compiler resolves
square (‘a’) to
square(int)

94
Compiler resolves
square (‘a’) to
square(char)
 3. A match through application of standard
C++ conversion rules

If no exact match or match through a promotion is

found, an attempt is made to achieve a match
through a standard conversion of the actual
argument. Consider the following example,
void afunc (char);
afunc (471);
//match through standard
conversion matches afunc (char)

96