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 [email protected]
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 [email protected] 9830030880
Outline Tanwi Mallick, TA [email protected] 9674277774
Default
Srijoni Majumdar, TA [email protected] 9674474267
Parameter Himadri B G S Bhuyan, TA [email protected] 9438911655
Function
Overloading
Overload
Resolution
Default
Parameters in
Overloading
Summary
NPTEL MOOCs Programming in C++ Partha Pratim Das 29
