Scribd
Upload
29 views

Lecture 14 Functions

1. This module discusses functions in C++, including creating and calling functions. Functions allow breaking a program into smaller, reusable parts. 2. Key aspects of functions include function declarations, definitions, parameters, return values, and scope. Functions can be overloaded by having different parameter types or counts. 3. Arguments are matched to parameters by position during a function call. The function performs its task and may return a value before control returns to the calling function.

Uploaded by

Muhammad Farid Haroon
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
29 views

Lecture 14 Functions

1. This module discusses functions in C++, including creating and calling functions. Functions allow breaking a program into smaller, reusable parts. 2. Key aspects of functions include function declarations, definitions, parameters, return values, and scope. Functions can be overloaded by having different parameter types or counts. 3. Arguments are matched to parameters by position during a function call. The function performs its task and may return a value before control returns to the calling function.

Uploaded by

Muhammad Farid Haroon
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 26

Module 7:

Functions
CS100 – Lecture # 14

Fall 2016

SBASSE, LUMS
Goals of this module
1. Functions in C++ (5.1 till 5.5)

2. Creating functions

3. Calling functions

2
Pre-defined functions
• Where did these predefined functions came from?
• #include<cmath>

• Then, can we also make such functions, which we


want to call upon when required?
• Yes, we can!

3
Remember the fun with cmath?

4
Understanding the program
control flow
• Consider the example:

• How does the control flow?


1. main calls the pow function
2. main function is temporarily suspended
3. pow function returns its result to the calling function

5
6
Things required to write a function
• When writing this function, you need to
1. Pick a name for the function (pow). <-Same as identifier

2. Declare a variable for each argument (int base, int


power). These variables are called parameter variables.

3. Specify the type of the return value (int).

• Cookie Point: What is the control flow and answer


to: pow(pow(2, 2), 2) ?

7
Anatomy of a function

8
Syntax of a function
• Two step process!

1. Function declaration (or function prototype)


• Shows how the function is called
• Must appear in the code before the function can be called
• Syntax:
Return_Type Function_Name(Parameter1_Type Parameter1_Name, …) ;
//Comment describing what function does

2. Function definition
• Describes how the function does its task
• Can appear before or after the function is called
• If appears after the function is called, then a function declaration before the call is required
• Syntax:
Return_Type Function_Name(Parameter1_Type Parameter1_Name, …)
{
//code to make the function work
}
9
Function Definition
• Declaration provides the footprint while definition provides the
implementation

function header
Example:

double total_cost(int number_par, double price_par)


{
const double TAX_RATE = 0.05; //5% tax
double subtotal;
subtotal = price_par * number_par;
return (subtotal + subtotal * TAX_RATE);
}

function body
10
11
The Return Statement
• Ends the function call

• Returns the value calculated by the function

• Syntax:
return expression;
• expression performs the calculation
or
• expression is a variable containing the
calculated value

• Example:
return subtotal + subtotal * TAX_RATE;
The Function Call
• Tells the name of the function to use

• Lists the arguments

• Is used in a statement where the returned value


makes sense

• Example:
double bill = total_cost(number, price);
Function Call Details
• The values of the arguments are plugged into the formal
parameters

• The first argument is used for the first formal


parameter, the second argument for the second
formal parameter, and so forth.

• The value plugged into the formal parameter is used


in all instances of the formal parameter in the
function body
Function Call Stack

15
http://www.bogotobogo.com/cplusplus/stackunwinding.php
Alternate Declarations
• Two forms for function declarations
• List formal parameter names
• List types of formal parmeters, but not names
• First aids description of the function in comments

• Examples:
double total_cost(int number_par, double price_par);

double total_cost(int, double);

• Function headers must always list formal parameter names!


Order of Arguments
• Compiler checks that the types of the arguments are correct and in the
correct sequence.

• Compiler cannot check that arguments are in the correct logical order

• Example: Given the function declaration:


char grade(int received_par, int min_score_par);

int received = 95, min_score = 60;

cout << grade( min_score, received);

• Produces a faulty result because the arguments are not in the correct
logical order. The compiler will not catch this!
Function Definition Syntax
• As you did in the “main” function, within a user-
defined function definition

• Variables must be declared before they are used

• Variables are typically declared before the


executable statements begin

• At least one return statement must end the function


• Each branch of an if-else statement might have its
own return statement
Placing Definitions
• A function call must be preceded by either
• The function’s declaration
or
• The function’s definition
• If the function’s definition precedes the call, a declaration is not
needed

• Placing the function declaration prior to the main


function and the function definition after the main
function leads naturally to building your own libraries
in the future.
Local Variables
• Variables declared in a function:
• Are local to that function, they cannot be used
from outside the function
• Have the function as their scope

• Variables declared in the main part of a program:


• Are local to the main part of the program, they
cannot be used from outside the main part
• Have the main part as their scope
Self test!
• Can you
1. Write a function declaration and a function definition
for a function that takes three arguments, all of type
int, and that returns the sum of its three arguments?

2. Describe the call-by-value parameter mechanism?

3. Write a function declaration and a function definition


for a function that takes one argument of type int and
one argument of type double, and that returns a value
of type double that is the average of the two
arguments?
Overloading Function Names
• C++ allows more than one definition for the same function
name
• Very convenient for situations in which the “same”
function is needed for different numbers or types
of arguments

• Overloading a function name means providing more than


one declaration and definition using the same function
name
Overloaded functions
• Must have different numbers of formal parameters

AND / OR

• Must have at least one different type of parameter

• Must return a value of the same type


Overloading Examples
• double ave(double n1, double n2)
{
return ((n1 + n2) / 2);
}
• double ave(double n1, double n2, double n3)
{
return (( n1 + n2 + n3) / 3);
}
• Compiler checks the number and types of arguments
in the function call to decide which function to use

cout << ave( 10, 20, 30);

uses the second definition


Automatic Type Conversion
• Given the definition
double mpg(double miles, double gallons)
{
return (miles / gallons);
}
what will happen if mpg is called in this way?

cout << mpg(45, 2) << “ miles per gallon”;

• The values of the arguments will automatically be


converted to type double (45.0 and 2.0)
Up next!
• Arrays

• Pointers

• Streams - Reading and Writing text Files

• Structures

26

You might also like