Lecture05

Lecture 05

Overloaded Functions
and
Inline Functions
Learn about:
Some functions that are not supported in C:
- Overloaded
- inline functions
- default arguments.

Ref.: OOP using C++, Joyce Farrel, Thopson Learning
1

Overloaded Functions (page 146-148)

• Overloaded functions are functions that have
similar name but each performs different
activities depending on the kind of data sent to
the function.

• The compiler uses the number of arguments,
and their data types, to distinguish one
function from another.

• Function overloading is not allowed in C.
2/15

Function Overloading
Example 1
#include <iostream.h> void repchar(char ch)
void repchar(); { for(int j=0; j<20; j++)
void repchar(char); cout << ch;
void repchar(char, int); cout << endl;
}
int main()
{ void repchar(char ch, int n)
repchar(); { for(int j=0; j<n; j++)
repchar('='); cout << ch;
repchar('+', 30); cout << endl;
return 0; }
}
void repchar() Output:
{ for(int j=0; j<20; j++) ********************
cout << '*'; ====================
cout << endl; +++++++++++++++++++++++++
3/15
}

Function Overloading
Example 2
#include <iostream.h> void show(double val)
{ cout << "Double: " << val
void show(int); << endl;
void show(double); }
void show(char*);
void show(char *val)
int main() { cout << "String: " << val
{ show(12); << endl;
show(3.1415); }
show("Hello World");
return 0; Output:
}
void show(int val) Integer: 12
{ cout<<"Integer: "<<val Double: 3.1415
<< endl; String: Hello World
} 4/15

Inline Functions (page 143-144)

• Functions are good for structured programming
but incur runtime overhead.

• An inline function is written like a normal
function but compiles into inline code which is
inserted into the program wherever a function
call occurs.

• Inline functions are not allowed in C.
5/15

Inline Functions : Overhead

: memory
: a 10
int main() {
func1(10, 20); b 20
: x 30
:
func1(40,50); • passing control to the function.
:
: • placing argument values in a memory.
} • returning to proper point in the
calling program.
void func1(int a, int b) {
: • providing a memory for any returned
x = a + b; value
:
} 6/15

Inline Functions: Example 1

#include <iostream.h>
inline void lbstokg(float pounds)
{
0.453592 * pounds;
}

void main()
{ float lbs;
cout<<"Enter weight in pounds: ";
cin>>lbs;
cout<<"Your weight in kg is "
<< lbstokg(lbs) << endl;
}

0.453592 * lbs
7/15

Inline Functions: Example 2

inline double computeGross(double hours, double rate)
{
return (hours * rate);
}

void main()
{
double hrsWorked = 37.5, rateOfPay = 12.45, gross;
gross = computeGross(hrsWorked, rateOfPay);
cout<<endl<<“Gross pay is “<<gross;
}

hrsWorked * rateOfPay
8/15

Inline Functions Vs Macros

• Inline functions are similar to macros declared
with the #define directive. The major
differences are:

– Inline functions are recognized by the compiler.
Macros are implemented by a simple text
substitution.

– Compiler performs type checking on the parameters
of an inline function. Macros have unwanted side
effects.
9/15

Inline Functions Vs Macros
Example

#define MAX(A,B) ( (A) > (B) ? (A) : (B))
inline int max(int a, int b) void main()
{ if (a > b) { int result,x,y;
return a; x = 23; y = 45;
result = MAX(x++, y++);
else cout << x << y << "n";
return b;
} x = 23; y = 45;
result = max(x++, y++);
cout << x << y << "n";
}

Output from the program:
2447
10/15
2446

Default Arguments (page 144 - 146)


void compute (int length, int width, int height)
{
………..
}

void main()
{ ……
compute (12, 7); // cause syntax error
}
11/15

Default Arguments (page 144 - 146)

• A function can be called without specifying all
its arguments.

• The function declaration must provide default
values for those arguments that are not
specified.

• Default arguments are not allowed in C.

12/15

Default Arguments: Example 1


void repchar(char='*', int=20);

void main()
{ repchar(); // print 20 '*'
repchar('='); // print 20 '='
repchar('+', 25); // print 25 '+'
}
Output:
void repchar(char ch, int n) ********************
{ ====================
for(int j=0; j<n; j++) +++++++++++++++++++++++++
cout << ch;
cout << endl;
}
13/15



void showstring(char *str = "Hello World!")
{ cout << str << endl;
}

void main()
{ showstring("Here's an explicit argument.");
showstring(); // in fact this says:
// showstring("Hello World!");
}
Output:
Here's an explicit argument.
Hello World!
14/15


void example(int, int = 5, float = 6.78);

void main()
{ example(7, 2, 9.3);
example(7, 2);
example(7);
}

void example(int x, int y, float z);
{ cout << x << y << z << endl;
}
Output:
7 2 9.3
7 2 6.78
7 5 6.78 15/15

Lecture05

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Lecture05 (20)

More from elearning_portal (14)

Lecture05