c++ ders3 - fonksiyonlar

Summary of what we learned last week

Basics of C++

Our first program: Hello world

Format of a program

Syntax of literals, keywords, symbols, variables

Data types

int (short, long, unsigned)

float/double

char

Arithmetic operations

Assignment (compound) operators

Standard input (cin) and output (cout)

More complex arithmetic operations and operator

precedence

Functions Functions Functions Functions (Chapter 2 (Chapter 2 (Chapter 2 (Chapter 2 Continued)Continued)Continued)Continued)

Main function will soon get big

Solution: Divide and Conquer

divide your problem into small ones

write one function for each

combine them in the main program

Advantages:

Main is organized into modular pieces

When you need to change something, you only

change that function and not main

Reuse the same code piece several times e.g. all programs use cin and cout

Functions Functions Functions Functions

Without functionWithout functionWithout functionWithout function

#include using namespace std;

/* traditional first program */

int main(){

cout

A program is a collection of functions and classes main and other programmer defined functions

only main is executed automatically when the program starts other functions must be called to be executed

Programmer-defined functions piece of code to do a specific job must be declared before using (calling)

return-type function-name(parameters){

local variablesstatements

}

to execute a function just write its name (and arguments for parameters) When a function is called, execution order temporarily jumps to function

after the function ends, execution order goes back to the caller

Syntax of Functions Syntax of Functions Syntax of Functions Syntax of Functions

Syntax for Functions Syntax for Functions Syntax for Functions Syntax for Functions


void Hello(){cout

Drawing Head Without functions

Draws a head but not so modular

To change head style, main needs to change.

Is this so bad?

What if you want to draw several heads like a totem?

You have to duplicate code

#include using namespace std;int main(){

cout

Drawing Head With functions

This one is more complicated, but what are the advantages?

Modularity

Change head style just change functions

What about eyeglasses?

Code re-use (not duplicated)

Multiple heads lets see totem.cpp

parts.cpp


// functions appear here

int main(){

Hair(); Sides();Eyes(); Ears(); Smile();Sides();return 0;

}

Functions with Parameters You may need to pass data into a function when you call it

Consider a generic function to calculate the area of any circle and display it how will the function know the radius?

solution: parameters function is defined without knowing the value of the radius

value of radius is passed to the function when it is called

parameters are defined similar to variablestype name Example: float radius

return-type func-name(type param1,,type param){

local variables

statements

}

Area calculation with parameterized function#include

using namespace std;

// area calculation program that employs functions

void calculate_area(float radius)

{

float area;

area = 3.14 * radius * radius;

cout

Area calculation with parameterized function

#include



void calculate_area (float radius)

{

float area;


cout

#include




{

float area;


cout

#include




{

float area;

area = 3.14*radius*radius;

cout

Functions with Parameters Parameters and Arguments

parameter is the generic name used in function radius in the calculate_area function

argument is the value passed to function while it is called 2.5

r (actually current value of r is passed)

r / 2 (actually current value of r / 2 is passed)

Parameter list provides type and name of the parameter Argument type must match parameter type

Functions may have multiple parameters corresponding arguments are separated by commas

in the same order of parameter list

be careful about the type matching

Functions may call other functions (have seen in the totem example and will see in the next example)

Functions with ParametersFunctions with ParametersFunctions with ParametersFunctions with Parameters Parameters versus Local Variables

Parameters are defined and used locally, but their initial value

comes from the caller function via arguments

Local variables are defined and used within the function

Initial value does not come from the caller function

While designing your functions, think carefully about local

variables and parameters

If you need to pass the initial value from the caller function, then

it should be a parameter.

If you wont pass the initial value, then it should be a local

variable.

Example: in calculate_area function

area is a local variable since we do not pass its initial value from main

radius is a parameter since we need to pass its initial value from main

Unnecessary parameters may cause problems and grade

reduction (for homework)

Old McDonalds Farm Goal is to have a modular program (with functions) to display the song

each verse repeats using a different animal

refrain parts repeat within verses

a partial output (with two animals only) below:

Old MacDonald had a farm, Ee-igh, Ee-igh, oh!

And on his farm he had a cow, Ee-igh, Ee-igh, oh!

With a moo moo here

And a moo moo there

Here a moo, there a moo, everywhere a moo moo



And on his farm he had a pig, Ee-igh, Ee-igh, oh!

With a oink oink here

And a oink oink there

Here a oink, there a oink, everywhere a oink oink


Old McDonaldOld McDonaldOld McDonaldOld McDonalds Farm s Farm s Farm s Farm

(Design of Functions)(Design of Functions)(Design of Functions)(Design of Functions)

Which functions do we need?

a function for only Ee-igh, Ee-igh, oh!

a function for the refrain (nakarat)

a function for And on his farm ... line

animal is parameter

a function for With a ..., And a ..., Here a ... lines

noise of the animal is a parameter

a function for the whole verse

Old McDonalds Farm (Program 1) See oldmac1.cpp

What is the problem? We need a new function for a new animal (e.g. chicken)

Cow and Pig functions are duplicates of each other.

Solution: Put the common code into a new function for the whole verse

Old McDonalds Farm (Program 2) See oldmac2.cpp

Verse does the common work with 2 parameters first one is for animal, second is for noise therefore it is called using 2 arguments first one is for animal, second is for noise

order of arguments is important

Functions call functions Refrain calls EiEio

Verse calls Refrain

animal is used as parameter name in two functions Should we need to use the same parameter name in both cases? Or can we use different names in two different functions?

Same questions are valid for noise as well.

Answer is Yes we can use different names.

Can we input animal and noise?

Mac Donalds farm with user input We want the user to enter/input values for animal and noise

Enter the name of an animal: sheepEnter noise that a sheep makes: baahOld MacDonald had a farm, Ee-igh, Ee-igh, oh!And on his farm he had a sheep, Ee-igh, ee-igh, oh!With a baah baah hereAnd a baah baah thereHere a baah, there a baah, everywhere a baah baahOld MacDonald had a farm, Ee-igh, Ee-igh, oh!

Well pass the user-entered values to the Verse function The input stream cin takes input from the keyboard using operator >>

Values that are input are stored in variables and then passed to function verse as arguments

see macinput2.cpp

Mac Donalds farm with user input// other functions goes here (see macinput2.cpp)

void Verse(string animal, string noise){ // this function doesnt change// see the source code for the function code

}

int main(){

string animal; // variable for name of animalstring noise; // variable for noise it makes

cout > animal;

cout

Analysis of the Run1. input value sheep is stored in variable animal

2. input value baah is stored in variable noise

3. sheep and baah values are passed to function Verse as arguments as well as used in cout in main

Variables (review from previous

lectures) Variables are used to store values in memory

memory locations that are accessed using a name

Each variable has a type, a name (identifier), and a value

Methods to give values to variables Assignment, using =

Input, using cin

Definition:

type variable_names_separated_by_comma;

Where to define variables You can define variables anywhere within a function

as long as it is defined before its first use

Two common places of variable definition At the beginning of the function in which theyre used:

{string animal, noise;cout > animal;cout animal;cout

Where to define variables NO GLOBAL VARIABLES

A global variable is a variable defined outside the function bodies


int global_number;

int main(){

cout

Variable Initialization Variables have garbage (junk values) until

they are assigned a value using assignment operator or myint = 5;

an input is stored into them (using cin statement) cin >> myint;

Variables must be given a value before being used for the first time in an expression or an output statement or as an argument to a function idea behind this rule: you can never know what is inside of an uninitialized variable !

not a syntax error, compiler may or may not warn you!

You may initialize variables at the declarationint mynumber = 5;

After initialization, you may change the value stored in a variable several times that is why they are named as variable

Scope of a Variable and Parameter

Not explained in the book in this way

RULE 1: A variable or parameter can be referred only

within the function in which it is declared

e.g. you cannot refer the variable animal in function Eieio

RULE 2: A specific identifier can be used several times in

different functions as variable or parameter names.

Those are actually different variables/parameters.

e.g. animal and noise are used both in main (as variable) and

Verse (as parameter)

RULE 3: A specific identifier must be unique within a

function

e.g. you cannot define a local variable animal in Verse since

there is a parameter named animal

Detailed scope rules will be given later in this course

Reading Assignment

Section 3.3 (page 83)

Case Study: Pizza Slices

Similar to circle area calculation program

Run the program pizza.cpp

Functions that return values

Functions weve written so far are void functions They do a job and return back to caller, but without a value

Parameters are used for one-way data transfer into the function to be called

How about transfer a computed value out of a function? to the main program or to other function (the caller)

Non-void functions can return values of any type function call becomes an expression

when the function finishes, the function call is replaced by the returned value

this way, values computed in functions can be transferred into the caller functions

void function call is not used in an expression, i.e. no value is associated with a void function

Head();DoThat();Verse("cow", "moo");

Functions that return values

Example (see area_func_return.cpp):

suppose circlearea function takes the radius as parameter and returns the

area.

In the program we call circlearea as an expression (you have to use the

returned value somewhere)

area = circlearea(r);

cout

Math library functions Mathematical functions like square root, logarithm, sin, cos, etc.

Prototypes are in header file cmath#include

Full list is in page 758 (Table F.1) partial list is in table 4.5. correction in Table F.1: int abs (int x)

Keep these math library functions on your cheat-sheet for the exam

Example use of function sqrt see usemath.cpp

how did we use sqrt function? in cout as an expression

could we use sqrt in assignment? How?

yes, lets do it.

what happens if value is negative?

try and see!

we can add some if statements to display an error message in case of negative value

return-type func-name(parameters){local variables

statements

}

Function Syntax

Example: Function to calculate volume of a sphere

double SphereVol(double radius){

return 4.0*radius*radius*radius*acos(-1)/3;}

function body

Function Syntax

double SphereVol(double radius){

return 4.0*radius*radius*radius*acos(-1)/3;}

Function heading/prototype shows return type. return type can be any type (including string)

theoretically return type may be Robot too, but in practice Robot class is not designed to be used as the return type

you do not see any syntax error, but execution may be problematic. So do not return a Robot from a function

Function body may have several statements in it

return statement is used to determine the value returned fromfunction, so the expression after it must be of the return type

Function body must include at least one return statement

The return statement causes the function to exit immediately and to return the value after return

A function can have more than one return statements, but only one is executed when the function is called (see next example)

Only one return is a good programming style to have control of bigger functions

Functions can return strings

string WeekDay(int day)

// precondition: 0

Function documentation

Functions usually have a precondition

What conditions (e.g. value of parameters) must be true for the

function to work as intended?

If there are no parameters, then no precondition

Some functions work for every parameter value

no precondition

Functions always have a postcondition

If precondition is satisfied what does the function do? What does

the function return?

Example Compare cost of pizza sizes

Problem: Calculate and compare price per square inch of large

and small size pizzas

Solution:

A function, say Cost, that takes the pizza radius and price as parameters

and returns price per square inch

In main()

input radiuses and prices of large and small pizzas

calculate the per square inch costs by calling the cost function

display the results on screen

compare the unit costs to find out which one is best value

See pizza2.cpp

Example - When is a year a leap year?

Every year divisible by four is a leap year

Except years divisible by 100 are not

Except years divisible by 400 are

Alternatively:

Every year divisible by 400 is a leap year

Otherwise, years divisible by 100 are not leap years

Otherwise, years divisible by 4 are leap years

Otherwise, not a leap year

Boolean functionbool IsLeapYear(int year);

// pre: year > 0

// post: return true if year is a leap year

Implementation and use of leap year functionbool IsLeapYear(int year)// precondition: year > 0// postcondition: returns true if year is a leap year, else returns false {

if (year % 400 == 0) // divisible by 400{ return true;}else if (year % 100 == 0) // divisible by 100{ return false;}else if (year % 4 == 0) // divisible by 4{ return true;}return false;

}int main(){

int year;cout > year;if (IsLeapYear(year)){ cout

Theres more than one way

No if/else necessary in the function body

bool IsLeapYear(int year)// precondition: year > 0// post: return true if year is a leap year{

return ( year % 400 == 0 ) ||( year % 4 == 0 && year % 100 != 0);

}

How does this work?

Is this version more efficient?

Are these two versions different from user perspective?

Function Prototype (from 2.6) Functions definition has two parts

function heading

name, parameters, return type

function body (local variables and statements within curly brackets)

void display (string name)

{

cout

Function Prototype Example Problem

What is the problem below (program order.cpp) ?

void Hi (string name){

cout

Function Prototype Solution

Add function prototypes to the beginning (order2.cpp)

#include #include using namespace std;

void Hi(string);void Greetings();

void Hi (string name){

cout

Function Prototypes *** Do not forget semicolon after the prototype

definition ***

no semicolon after the parameters in normal definition

Sometimes prototypes are not necessary

if the order of function calls allows

but it is good programming practice to have them

Parameter names are not needed in prototypes

but it is OK if you have the parameter names

In #included files

we have the functions prototypes only

implementations of function bodies are in libraries or in other

cpp files

they are linked together

c++ ders3 - fonksiyonlar

Documents