Module 08

Partha Pratim
Das Module 08: Programming C++
Objectives & Default Parameters & Function Overloading
Outline

Default
Parameter

Function Partha Pratim Das

Overloading

Overload
Resolution Department of Computer Science and Engineering
Indian Institute of Technology, Kharagpur
Default
Parameters in ppd@cse.iitkgp.ernet.in
Overloading

Summary
Tanwi Mallick
Srijoni Majumdar
Himadri B G S Bhuyan

NPTEL MOOCs Programming in C++ Partha Pratim Das 1

 Module Objectives

Module 08

Partha Pratim Understand default parameters

Das
Understand function overloading and Resolution
Objectives &
Outline

Default
Parameter

Function
Overloading

Overload
Resolution

Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 2

 Module Outline

Module 08

Partha Pratim Default parameter

Das
Motivation
Objectives & Call function with default parameter
Outline
Highlighted Points
Default
Parameter
Restrictions
Function Function overloading
Overloading
Meaning & Motivation
Overload
Resolution Necessity of function overloading in Contrast with C
Default Static Polymorphism
Parameters in
Overloading Meaning
Summary Overloading function
Overload Resolution
Default parameters and Function Overloading

NPTEL MOOCs Programming in C++ Partha Pratim Das 3

 Module 08: Lecture 12

Module 08

Partha Pratim Default parameter

Das
Motivation
Objectives & Call function with default parameter
Outline
Highlighted Points
Default
Parameter
Restrictions
Function
Overloading

Overload
Resolution

Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 4

 Motivation: Example CreateWindow in MSDN

Module 08 Declaration of CreateWindow Calling CreateWindow

Partha Pratim HWND WINAPI CreateWindow( hWnd = CreateWindow(

Das _In_opt_ LPCTSTR lpClassName, ClsName,
_In_opt_ LPCTSTR lpWindowName, WndName,
_In_ DWORD dwStyle, WS_OVERLAPPEDWINDOW,
Objectives & _In_ int x, CW_USEDEFAULT,
Outline _In_ int y, CW_USEDEFAULT,
_In_ int nWidth, CW_USEDEFAULT,
Default
_In_ int nHeight, CW_USEDEFAULT,
Parameter
_In_opt_ HWND hWndParent, NULL,
Function _In_opt_ HMENU hMenu, NULL,
Overloading _In_opt_ HINSTANCE hInstance, hInstance,
_In_opt_ LPVOID lpParam NULL
Overload ); );
Resolution

Default There are 11 Number of parameters in CreateWindow()

Parameters in
Overloading Out of these 11, 7 parameters (4 are CWUSEDEFAULT and 3 are NULL) usually
Summary get fixed values in a call
Instead of using these 7 fixed valued Parameters at the time of calling, we
could have avoided those by assigning those value much earlier in function
formal parameter

C++ allows us to do so through the mechanism called Default parameters

NPTEL MOOCs Programming in C++ Partha Pratim Das 5
 Program 08.01: Function with a default parameter

Module 08

Partha Pratim #include <iostream>

Das
using namespace std;
Objectives &
Outline int IdentityFunction(int a = 10) { // Default value for the parameter
return (a);
Default
Parameter }
Function
Overloading
int main() {
int x = 5, y;
Overload
Resolution
y = IdentityFunction(x); // Usual function call
Default cout << "y = " << y << endl;
Parameters in
Overloading
y = IdentityFunction(); // Uses default parameter
Summary
cout << "y = " << y << endl;
}
----------
y = 5
y = 10

NPTEL MOOCs Programming in C++ Partha Pratim Das 6

 Program 08.02: Function with 2 default parameters

Module 08 #include<iostream>
using namespace std;
Partha Pratim
Das
int Add(int a = 10, int b = 20) {
Objectives & return (a + b);
Outline }
Default int main(){
Parameter int x = 5, y = 6, z;
Function
Overloading z = Add(x, y); // Usual function call -- a = x = 5 & b = y = 6
Overload
cout << "Sum = " << z << endl;
Resolution

Default
z = Add(x); // One parameter defaulted -- a = x = 5 & b = 20
Parameters in cout << "Sum = " << z << endl;
Overloading

Summary z = Add(); // Both parameter defaulted -- a = 10 & b = 20

cout << "Sum = " << z << endl;
}
----------
Sum = 11
Sum = 25
Sum = 30
NPTEL MOOCs Programming in C++ Partha Pratim Das 7
 Default Parameter: Highlighted Points

Module 08

Partha Pratim C++ allows programmer to assign default values to the

Das
function parameters
Objectives &
Outline Default values are specified while prototyping the function
Default
Parameter
Default parameters are required while calling functions
Function
with fewer arguments or without any argument
Overloading
Better to use default value for less used parameters
Overload
Resolution Default arguments may be expressions also
Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 8

 Restrictions on default parameters

Module 08 All parameters to the right of a parameter with default

Partha Pratim argument must have default arguments (function f)
Das
Default arguments cannot be re-defined (function g)
Objectives &
Outline All non-defaulted parameters needed in a call (call g())
#include <iostream>
Default
Parameter void f(int, double = 0.0, char *);
Function // Error C2548: ’f’: missing default parameter for parameter 3
Overloading
void g(int, double = 0, char * = NULL); // OK
Overload void g(int, double = 1, char * = NULL);
Resolution // Error C2572: ’g’: redefinition of default parameter : parameter 3
// Error C2572: ’g’: redefinition of default parameter : parameter 2
Default
Parameters in int main() {
Overloading int i = 5; double d = 1.2; char c = ’b’;

Summary g(); // Error C2660: ’g’: function does not take 0 arguments
g(i);
g(i, d);
g(i, d, &c);
return 0;
}

NPTEL MOOCs Programming in C++ Partha Pratim Das 9

 Module 08: End Of Lecture 12

Module 08

Partha Pratim Default parameter

Das
Motivation
Objectives & Call function with default parameter
Outline
Highlighted Points
Default
Parameter
Restrictions
Function
Overloading

Overload
Resolution

Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 10

 Module 08: Lecture 13

Module 08

Partha Pratim Default parameter Restrictions

Das
Function overloading
Objectives &
Outline
Meaning & Motivation
Default
Necessity of function overloading in Contrast with C
Parameter Restrictions on function overloading
Function
Overloading

Overload
Resolution

Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 11

 Restrictions on default parameters

Module 08 Default parameters should be supplied only in a header file

Partha Pratim
and not in the definition of a function
// Header file: myFunc.h
Das
void g(int, double, char = ’a’);
----------------------------------------------------
Objectives & // Source File: myFunc.cpp
Outline #include <iostream>
using namespace std;
Default #include "myFunc.h"
Parameter
void g(int i, double d, char c) {
Function cout << i << ’ ’ << d << ’ ’ << c << endl;
Overloading }
----------------------------------------------------
Overload
// Application File: Apps.cpp
Resolution
#include <iostream>
Default #include "myFunc.h"
Parameters in // void g(int, double, char = ’a’);
Overloading
void g(int i, double f = 0.0, char ch); // OK a new overload
Summary void g(int i = 0, double f, char ch); // OK a new overload
int main() {
int i = 5; double d = 1.2; char c = ’b’;

g(); // Prints: 0 0 a
g(i); // Prints: 5 0 a
g(i, d); // Prints: 5 1.2 a
g(i, d, c); // Prints: 5 1.2 b
return 0;
}
NPTEL MOOCs Programming in C++ Partha Pratim Das 12
 Function overloads: Matrix Multiplication in C
Similar functions with different data types & algorithms
Module 08
typedef struct { int data[10][10]; } Mat; // 2D Matrix
Partha Pratim typedef struct { int data[1][10]; } VecRow; // Row Vector
Das typedef struct { int data[10][1]; } VecCol; // Column Vector

Objectives & void Multiply_M_M (Mat a, Mat b, Mat* c) { /* c = a * b */ }

Outline void Multiply_M_VC (Mat a, VecCol b, VecCol* c) { /* c = a * b */ }
void Multiply_VR_M (VecRow a, Mat b, VecRow* c) { /* c = a * b */ }
Default void Multiply_VC_VR(VecCol a, VecRow b, Mat* c) { /* c = a * b */ }
Parameter void Multiply_VR_VC(VecRow a, VecCol b, int* c) { /* c = a * b */ }

Function int main() {

Overloading Mat m1, m2, rm; VecRow rv, rrv; VecCol cv, rcv; int r;
Multiply_M_M (m1, m2, &rm); // rm <-- m1 * m2
Overload Multiply_M_VC (m1, cv, &rcv); // rcv <-- m1 * cv
Resolution Multiply_VR_M (rv, m2, &rrv); // rrv <-- rv * m2
Multiply_VC_VR(cv, rv, &rm); // rm <-- cv * rv
Default
Multiply_VR_VC(rv, cv, &r); // r <-- rv * cv
Parameters in
return 0;
Overloading
}
Summary
5 multiplication functions share same functionality but different
argument types
C treats them as 5 separate functions
C++ has an elegant solution
NPTEL MOOCs Programming in C++ Partha Pratim Das 13
 Function overloads: Matrix Multiplication in C++

Module 08
Functions having similar functionality but different in details.
Partha Pratim
Das typedef struct { int data[10][10]; } Mat; // 2D Matrix
typedef struct { int data[1][10]; } VecRow; // Row Vector
Objectives & typedef struct { int data[10][1]; } VecCol; // Column Vector
Outline
void Multiply(const Mat& a, const Mat& b, Mat& c) { /* c = a * b */ };
Default void Multiply(const Mat& a, const VecCol& b, VecCol& c) { /* c = a * b */ };
Parameter void Multiply(const VecRow& a, const Mat& b, VecRow& c) { /* c = a * b */ };
void Multiply(const VecCol& a, const VecRow& b, Mat& c) { /* c = a * b */ };
Function void Multiply(const VecRow& a, const VecCol& b, int& c) { /* c = a * b */ };
Overloading
int main() {
Overload
Mat m1, m2, rm; VecRow rv, rrv; VecCol cv, rcv; int r;
Resolution
Multiply(m1, m2, rm); // rm <-- m1 * m2
Default Multiply(m1, cv, rcv); // rcv <-- m1 * cv
Parameters in Multiply(rv, m2, rrv); // rrv <-- rv * m2
Overloading Multiply(cv, rv, rm); // rm <-- cv * rv
Multiply(rv, cv, r); // r <-- rv * cv
Summary return 0;
}

These 5 functions having different argument types are treated

as one function (Multiply) in C++
This is called Function Overloading or Static Polymorphism
NPTEL MOOCs Programming in C++ Partha Pratim Das 14
 Program 08.03/04: Function Overloading

Module 08 Define multiple functions having the same name

Partha Pratim
Das
Binding happens at compile time
Same # of Parameters Different # of Parameters
Objectives &
Outline #include <iostream> #include <iostream>
using namespace std; using namespace std;
Default int Add(int a, int b) { return (a + b); } int Area(int a, int b) { return (a * b); }
Parameter double Add(double c, double d) { int Area(int c) {
return (c + d); return (c * c);
Function } }
Overloading int main() { int main(){
int x = 5, y = 6, z; int x = 10, y = 12, z = 5, t;
Overload z = Add(x, y); t = Area(x, y);
Resolution // int Add(int, int) // int Add(int, int)
cout << "int sum = " << z; cout << "Area of Rectangle = " << t;
Default
Parameters in double s = 3.5, t = 4.25, u; int z = 5, u;
Overloading u = Add(s, t); u = Area(z);
// double Add(double, double) // int Add(int)
Summary
cout << "double sum = " << u << endl; cout << " Area of Square = " << u << endl;

return 0; return 0;
} }

int sum = 11 double sum = 7.75 Area of Rectangle = 12 Area of Square = 25

• Same Add function • Same Area function
• Same # of parameters but different types • Different # of parameters

NPTEL MOOCs Programming in C++ Partha Pratim Das 15

 Program 08.05: Restrictions in Function
Overloading
Module 08 Two functions having the same signature but different return
Partha Pratim types cannot be overloaded
Das
#include <iostream>
Objectives & using namespace std;
Outline
int Area(int a, int b) { return (a * b); }
Default double Area(int a, int b) { return (a * b); }
Parameter // Error C2556: ’double Area(int,int)’: overloaded function differs only by return type
// from ’int Area(int,int)’
Function // Error C2371: ’Area’: redefinition; different basic types
Overloading
int main() {
Overload
int x = 10, y = 12, z = 5, t;
Resolution
double f;
Default
Parameters in t = Area(x, y);
Overloading // Error C2568: ’=’: unable to resolve function overload
// Error C3861: ’Area’: identifier not found
Summary
cout << "Multiplication = " << t << endl;

f = Area(y, z); // Errors C2568 and C3861 as above

cout << "Multiplication = " << f << endl;

return 0;
}

NPTEL MOOCs Programming in C++ Partha Pratim Das 16

 Module 08: End of Lecture 13

Module 08

Partha Pratim Default parameter Restrictions

Das
Function overloading
Objectives &
Outline
Meaning & Motivation
Default
Necessity of function overloading in Contrast with C
Parameter Restrictions on function overloading
Function
Overloading

Overload
Resolution

Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 17

 Module 08: Lecture 14

Module 08

Partha Pratim Function overloading Rules

Das
Function Overload resolution
Objectives &
Outline
Exact match
Default
Promotion & conversion
Parameter
Default parameter & function overloading
Function
Overloading

Overload
Resolution

Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 18

 Function Overloading – Summary of Rules

Module 08 The same function name may be used in several definitions

Partha Pratim
Das Functions with the same name must have different number of
formal parameters and/or different types of formal parameters
Objectives &
Outline Function selection is based on the number and the types of the
Default
Parameter
actual parameters at the places of invocation
Function Function selection (Overload Resolution) is performed by the
Overloading
compiler
Overload
Resolution
Two functions having the same signature but different return
Default
Parameters in
types will result in a compilation error due to attempt to
Overloading re-declare
Summary
Overloading allows Static Polymorphism

NPTEL MOOCs Programming in C++ Partha Pratim Das 19

 Overload Resolution

Module 08

Partha Pratim To resolve overloaded functions with one parameter

Das
Identify the set of Candidate Functions
Objectives & From the set of candidate functions identify the set of
Outline
Viable Functions
Default
Parameter
Select the Best viable function through (Order is
important)
Function
Overloading Exact Match
Overload Promotion
Resolution Standard type conversion
Default User defined type conversion
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 20

 Overload Resolution: Exact Match

Module 08

Partha Pratim lvalue-to-rvalue conversion

Das
Most common
Objectives &
Outline
Array-to-pointer conversion
Default
Definitions: int ar[10];
Parameter
void f(int *a);
Function
Overloading Call: f(ar)
Overload Function-to-pointer conversion
Resolution
Definitions: typedef int (*fp) (int);
Default
Parameters in void f(int, fp);
Overloading
int g(int);
Summary
Call: f(5, g)
Qualification conversion
Converting pointer (only) to const pointer

NPTEL MOOCs Programming in C++ Partha Pratim Das 21

 Overload Resolution: Promotion & Conversion

Module 08

Partha Pratim Examples of Promotion

Das
char to int; float to double
Objectives & enum to int / short / unsigned int / ...
Outline
bool to int
Default
Parameter Examples of Standard Conversion
Function integral conversion
Overloading
floating point conversion
Overload
Resolution floating point to integral conversion
Default The above 3 may be dangerous!
Parameters in
Overloading
pointer conversion
bool conversion
Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 22

 Example: Overload Resolution with one parameter

Module 08 In the context of a list of function prototypes:

Partha Pratim int g(double); // F1
Das
void f(); // F2
Objectives &
void f(int); // F3
Outline double h(void); // F4
Default
int g(char, int); // F5
Parameter void f(double, double = 3.4); // F6
void h(int, double); // F7
Function
Overloading void f(char, char *); // F8
Overload
Resolution
The call site to resolve is:
Default f(5.6);
Parameters in
Overloading

Summary Resolution:
Candidate functions (by name): F2, F3, F6, F8
Viable functions (by # of parameters): F3, F6
Best viable function (by type double – Exact Match): F6

NPTEL MOOCs Programming in C++ Partha Pratim Das 23

 Example: Overload Resolution fails

Module 08
• Consider the overloaded function signatures:
Partha Pratim
Das int fun(float a) {...} // Function 1
int fun(float a, int b) {...} // Function 2
Objectives & int fun(float x, int y = 5) {...} // Function 3
Outline

Default int main() {

Parameter
float p = 4.5, t = 10.5;
Function int s = 30;
Overloading

Overload fun(p, s); // CALL - 1

Resolution fun(t); // CALL - 2
Default return 0;
Parameters in }
Overloading

Summary
• CALL - 1: Matches Function 2 & Function 3
• CALL - 2: Matches Function 1 & Function 3
• Results in ambiguity

NPTEL MOOCs Programming in C++ Partha Pratim Das 24

 Program 08.06/07:
Default Parameter & Function Overload
Module 08 Compilers deal with default parameters as a special case of
Partha Pratim function overloading
Das
Default Parameters Function Overload
Objectives & #include <iostream> #include <iostream>
Outline using namespace std; using namespace std;
int f(int a = 1, int b = 2); int f();
Default int f(int);
Parameter int f(int, int);
Function
int main() { int main() {
Overloading
int x = 5, y = 6; int x = 5, y = 6;
Overload
Resolution f(); // a = 1, b = 2 f(); // int f();
f(x); // a = x = 5, b = 2 f(x); // int f(int);
Default f(x, y); // a = x = 5, b = y = 6 f(x, y); // int f(int, int);
Parameters in
Overloading return 0; return 0;
} }
Summary
• Function f has 2 parameters overloaded • Function f is overloaded with up to 3 parameters
• f can have 3 possible forms of call • f can have 3 possible forms of call
• No overload here use default parameters

NPTEL MOOCs Programming in C++ Partha Pratim Das 25

 Program 08.08:
Default Parameter & Function Overload
Module 08 Function overloading can use default parameter
Partha Pratim However, with default parameters, the overloaded functions
Das
should still be resolvable
Objectives & #include<iostream>
Outline
using namespace std;
Default
Parameter
int Area(int a, int b = 10) { return (a * b); }
Function double Area(double c, double d) { return (c * d); }
Overloading

Overload int main() {

Resolution int x = 10, y = 12, t;
Default double z = 20.5, u = 5.0, f;
Parameters in
Overloading
t = Area(x); // Binds int Area(int, int = 10)
Summary cout << "Area = " << t << endl; // t = 100

f = Area(z, u); // Binds double Area(double, double)

cout << "Area = " << f << endl; // f = 102.5

return 0;
}
NPTEL MOOCs Programming in C++ Partha Pratim Das 26
 Program 08.09:
Default Parameter & Function Overload
Module 08 Function overloading with default parameters may fail
Partha Pratim
Das #include <iostream>
using namespace std;
Objectives & int f();
Outline int f(int = 0);
Default int f(int, int);
Parameter

Function int main() {

Overloading int x = 5, y = 6;
Overload
Resolution f(); // Error C2668: ’f’: ambiguous call to overloaded function
Default
// More than one instance of overloaded function "f"
Parameters in // matches the argument list:
Overloading // function "f()"
Summary // function "f(int = 0)"

f(x); // int f(int);

f(x, y); // int f(int, int);

return 0;
}
NPTEL MOOCs Programming in C++ Partha Pratim Das 27
 Module Summary

Module 08

Partha Pratim Introduced the notion of Default parameters and discussed

Das
several examples
Objectives &
Outline Identified the necessity of function overloading
Default
Parameter
Introduced static Polymorphism and discussed examples
Function
and restrictions
Overloading
Discussed an outline for Overload resolution
Overload
Resolution Discussed the mix of default Parameters and function
Default
Parameters in
overloading
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 28

 Instructor and TAs

Module 08

Partha Pratim
Das Name Mail Mobile
Objectives &
Partha Pratim Das, Instructor ppd@cse.iitkgp.ernet.in 9830030880
Outline Tanwi Mallick, TA tanwimallick@gmail.com 9674277774
Default
Srijoni Majumdar, TA majumdarsrijoni@gmail.com 9674474267
Parameter Himadri B G S Bhuyan, TA himadribhuyan@gmail.com 9438911655
Function
Overloading

Overload
Resolution

Default
Parameters in
Overloading

Summary

NPTEL MOOCs Programming in C++ Partha Pratim Das 29