C++ functions require prototypes that specify the return type and parameters. Function overloading allows multiple functions to have the same name but different signatures. Default arguments allow functions to be called without providing trailing arguments. Inline functions expand the function body at the call site for small functions to reduce overhead compared to regular function calls.

2. Objectives
In this chapter you will learn about
•Strict type checking
•Function Overloading
•Default Arguments
•Inline Function

3. • In C, Prototype is not required if the function
returns integer.
• printf can be used without including stdio.h

4.  In C++, prototype is compulsory even if functions
return int.
 Inclusion of stdio.h is compulsory if you are using printf
function.

5. C PROGRAM C PROGRAM

6. • Can we pass argument for function given the
following Prototype
• int func();
• In C –Yes , says that a function can take zero or more
number of arguments. (K & R Style of Prototyping)
• In C++ - No, says that a function takes zero arguments

7.  A feature of C++ which allows multiple functions to
have same function name
 Calls to an overloaded function are resolved using
function signatures.
 Allows multiple functions which perform similar tasks
to be grouped under a single name “single interface
and multiple implementations”

9.  How does C++ compiler distinguishes
between different functions when it
generates object code
 It changes names by adding information
about arguments.
 This technique of adding additional
information to function names is
called Name Mangling

11.  What is the difference between strcpy
and strncpy?
 Write two functions by name mystrcpy.
• First functions takes two arguments (dest , src)
• Second takes three arguments(dest,src,n);

13.  “Single interface multiple implementations” is
technically termed as “Polymorphism”.
 The binding takes place during compile time, so its
called “compile time polymorphism” or “static
polymorphism”.
 Ensure that function overloading in unambiguous

15. int main( )
{
char str[50];
cout <<"Enter a name : ";
cin >> str;
cout <<"Entered name is " << str;
}
.getline(str , 50 );; .getline(str , 50 , ‘.’ );

16. • A default argument is a value provided in function declaration
that is automatically assigned by the compiler if caller of the
function doesn't provide a value for the argument.
• Allows a function to be called without providing one or more
trailing arguments.

17. • Default arguments should be provided only in function prototype
and shouldn’t be repeated in function definition.The compiler
uses the prototype to build a function call and not the function
definition.
• Only trailing arguments should be given default values. i.e., you
cant have a default argument followed by a non default argument.

18. void printBinary(int num,int bits = 8);
int main( )
{
printBinary(23);
printBinary(500 , 16);
printBinary(28 );
}
void printBinary(int num,int bits)
{
for(int i = bits - 1 ; i >= 0 ; i--)
cout << ((num & 1 << i )?1:0) ;
}

21.  If a function is declared as inline, at the time of
compilation, the body of the function is expanded at the
point at which it is invoked.
 For small functions, the inline function removes all the
overheads of function calls.
 To make a function inline prefix the keyword inline
before the function name Syntax is
 inline <return_Type> <Func_Name>(arguments)

22.  Not all requests to make a function inline are honored.
Generally C++ examines the
• complexity of the function
• should request for inline replacement only if the functions are short.
 The compiler may ignore the function as inline when:
• If there are loops, switch statements or goto’s in the function
• If there are static variables in a function
• If the function is recursive
• If the function call and function definition are not in a single translation
unit

23.  Inline functions are functionally similar to #define
macros. In both the cases, the body of the macro or the
function is expanded. But inline functions are preferred
over macros because of three main reasons:
• Argument Evaluation - Arguments are first evaluated and then
expanded unlike in macros where arguments are expanded and then
evaluated.
• Type Checking - The types of the arguments are checked against the
parameter list in the declaration for the function. As a result, any
mismatch in the parameters can be detected at the time of
compilation.
• Overloading - inline functions can be overloaded, which is not
possible in the case of macros.

26. #define square(x) x * x
OR
inline int square(int x)
{
return x * x;
}
int main( )
{
int x = 5;
cout << square( x + 2) << endl;
return 0;
}

28. • Prototypes are a must in C++
• Every function should have a explicit return-type.
• Multiple functions can have same name with
different signature.
• Default parameters allows us to pass lesser
arguments to functions.
• Default parameters will help in combining multiple
functions into one.
• Inline functions to be used as alternative to macros
• Reference is an alternate name given to existing
variable