PRINCIPLE OF

PROGRAMMING
Let‘s try this:
 Write a program that can add,
subtract, multiply and divide two
numbers.
#include <iostream>

using namespace std;

int main ()
{
int a, b, addresult, subresult, mulresult, divresult;
cout << "Enter two integers : ";
cin >> a >> b;
addresult = a+b;
subresult = a-b;
mulresult = a * b;
divresult = a / b;
cout << endl << endl << "Addition result = " << addresult;
cout << endl << "Subtract result = " << subresult;
cout << endl << "Multiply result = " << mulresult;
cout << endl << "Divide result = " << divresult << endl;
system("pause");
}
 There are so many
functions in main().

We can separate the functions

(add, subtract, multiply and
divide ) into several
functions.

So, how to
divide them ?
#include <iostream>
using namespace std;
int main()
{
int a,b, tolak, mulresult, addresult, subresult;
int divresult;
//Input value
//Input value
cout << "Enter two integers : ";
cout << "Enter two integers : ";
cin >> a >> b; cin >> a >> b;

//Arithmetic operation
addresult = a + b; //Arithmetic operation
subresult = a - b; addresult = a + b;
mulresult = a * b; subresult = a - b;
divresult = a / b; mulresult = a * b;
divresult = a / b;
//Output printing
cout << "Addition result = " << addresult << endl;
//Output printing
cout << "Subtract result = " << subresult << endl;
cout << "Addition result = " << addresult << endl;
cout << "Multiply result = " << mulresult << endl; cout << "Subtract result = " << subresult << endl;
cout << "Divide result = " << divresult << endl; cout << "Multiply result = " << mulresult << endl;
cout << "Divide result = " << divresult << endl;
}
 Modular programming in C++ is called Functions
 Breaking a program up into smaller, manageable functions or
modules
 Module can be divided into sub-modules
 Benefits:
 Program structure is readable
 Make program development more manageable
 Problem can viewed in a smaller scope
 Program development are much faster compared to the common
structure
 Software reusability – using existing functions as building block to
create new program
 Improves maintainability of programs
 Simplifies the process of writing programs
Function Is a program segment that performs specific
tasks, made up of C++ statements

Has TWO types:

User-defined functions
Created by user for
Standard library functions specific purposes
-Example:
exit(), cin, cout, getch()

Function prototype

Functions Function definition

elements
Function call
#include <iostream>
using namespace std; //Arithmetic operation
void Calculate()
int a, b, mulresult, addresult, subresult; {
int divresult; addresult = a + b;
void InputValue(); subresult = a - b;
void Calculate(); Function mulresult = a * b; Function
void PrintResult(); prototype divresult = a / b; definition
}
int main() //Output printing
{ void PrintResult()
InputValue(); {
Calculate(); Function call cout << "Addition result = " << addresult << endl;
PrintResult(); cout << "Subtract result = " << subresult << endl;
} cout << "Multiply result = " << mulresult << endl;
cout << "Divide result = " << divresult << endl;
//Input value }
void InputValue()
{
cout << "Enter two integers : ";
cin >> a >> b;
}
 Must be added to a C++ program before the main
function, IF call that function before defining it.
 It tells the compiler:
 What type of value the function returns
 Number and types of parameters
 Order in which these parameters are expected
 There is no need for a prototype if the function is
called after its definition
.
void addition (int a, int b);
or
void addition (int, int);

Where:
a & b -Parameters

int - datatype

addition - Function name

void - Function return type

#include <iostream>
using namespace std;
void addition ( int, int ); Function Prototype
void subtract ( int, int );
int main ( )
{
int a, b;
cout >> a >> b;
addition(a,b);
subtract(a,b);
}

void addition (int a, int b)

{
int addresult = a+b;
cout << “Addition result = ” << addresult;
}

void subtract (int a, int b)

{
int ubresult = a-b;
cout << “Subtract result = ” << subresult;
}
 A function definition has two principal components:
 The first line (including argument declarations)
 The body of the function.
 The first line of a function definition contains
 Type of the value returned by the function (the function
type)
 The function name
 An optional list of formal parameters, separated by
commas and enclosed in parentheses
 #include <iostream>
using namespace std;
void addition ( int, int );
void subtract ( int, int );

int main ()
{
int a, b;
cout >> a >> b; Formal parameters
addition(a,b); data type
subtract(a,b);
}
a and b are
Function Function formal
return type name parameters

void addition (int a, int b)

{ Function
addresult = a+b; Definition
cout << “Addition result =” << addresult;
}

void subtract (int a, int b)

{
subresult = a-b;
cout << “Subtract result = ” << subresult);
}
void addition (int a, int b) First line

{
addresult = a+b;
cout << “Addition result =” << addresult;
}

Body
  Format a function definition:
functionreturn_type function_name (formal_parameters)
{
declaration
statement
} A return value of type void
indicates a function
does not return a value.
void addition (int a, int b)
{
addresult = a+b;
cout << “Addition result =” << addresult);
}
 a and b are
Parameters/
Arguments
void addtion (int a, int b)
{
addresult = a+b;
cout << “Addition result = ” << addresult;
}
#include <iostream>

using namespace std;

int mod(int, int); /* Function Prototype */

int main()
{
cout << "The mod is: " << mod(4,5));
}

int mod(int a, int b) /* Function Definition */

{
return a % b;
}
#include <iostream>

using namespace std;

int sum(int a, int b) /* Function Definition */

{
return a+b;
}

int main()
{
printf("The sum is: " << sum(4,5));
}
 A function can can be accessed (i.e., called) by
 specifying function name, followed by a list of arguments enclosed
in parentheses and separated by commas
 If the function call does not require any arguments
 empty pair of parentheses must follow the name of the function.
 The arguments appearing in the function call are referred to as
actual arguments, in contrast to the formal arguments that
appear in the first line of the function definition.
#include <iostream>
void addition ( int, int );
void subtract ( int, int );

int main ()
{
int a, b;
cin >> a >> b;
addition(a,b); a and b are actual
subtract(a,b); Function calls parameters /
} arguments in
function call
void addition (int c, int d)
{
Function definition
addresult = c + d;
cout << “Addition result =” << addresult);

}
c, d, e and f are
void subtract (int e, int f) formal parameters /
{ arguments in
subresult = e - f; function definition
cout << “Subtract result = ” << subresult);

}
 In a normal function call
 there will be one actual argument for each formal argument.
 may be expressed as constants, single variables, or more
complex expressions.
 If the function returns a value, the function access is
written a statement; e.g.,
b = sum(a);
 If the function does not return anything, the function
access appears by itself; e.g.,
view(a,b,c);
A function can be called by
the main function
other functions
itself (recursion)

In C++, functions call can be

by value
by reference
 • Example Call By Value

finval = FuncByValue(finval);

/*The FuncByValue function*/

finval is type
float float FuncByValue(float fval)
to receive the
result of {
fval*fval return fval*fval;
}
• Example Call By Reference
FuncByReference(&finref)

• Use & to pass the address of a variable to the function

• Value of the referenced variable passed to the function is

modified after returning from the function.

the function void FuncByReference(float *fvalptr)

access appears {
by itself since it *fvalptr = *fvalptr * *fvalptr;
does not return }
a value
•Scope determine where the variable will be used.
•Two types of scope: GLOBAL and LOCAL

It’s scope begins at the point of its

GLOBAL variable declarations and terminates at the end
of file.

Example
#include <iostream>
Declared before main() using namespace std;
int a,b;
a, b and c are float c;
global variable int main()
{
}
 Variable that can be accessed inside the
main() function or the function that
LOCAL variable declares it.

Example
#include <iostream>
Declares inside
using namespace std;
main() function or any
void getvalue();
other functions
int main()
{ int x; }
x is a local variable to
main() function and z is a void getvalue()
local variable to getvalue() { int z;
…………
function
}
Example 1:
#include <iostream>
using namespace std;

int a, b; //global variable

void display();

int main()
{ cout << “\nEnter value of a and b : ”;
cin >> a >> b;
display();
}

void display()
{
cout << “Value a is ” << a << “and b is ” << b << endl;
}
Example 2:
#include <iostream>
using namespace std;
Output?
int a, b; //global variables
void display();

int main()
{ int c; //local variable
a= 5;
b = 9;
c = 12;
display();
cout << “\nValue c is ” << c << endl;
}

void display()
{
cout << “\nValue a is ” << a << endl;
cout << “\nValue b is ” << b << endl;
cout << “\nValue c is ” << c << endl;
}
Example 3:
#include <iostream> Output?
using namespace std;

void display();

void main()
{ int c; // local variable
a= 5;
b = 9;
c = 12;
display();
cout << “\nValue c is ” << c << endl
}
void display()
{ int a, b; //local variables
cout << “\nValue a is ” << a << endl;
cout << “\nValue b is ” << b << endl;
}
 Example 4:

#include <iostream>
using namespace std; void function1()
{ int i,j ;
void function1(); i= 3;
void function2(); j = i;
int z; cout << “\nValue i is ” << i << endl;
cout << “\nValue j is ” << j << endl;
int main() }
{ function1();
x = 7; void function2()
z = 15; { int x = 4;
function2(); z = j;
} cout << “\nValue x is ” << x << endl;
cout << “\nValue z is ” << z << endl;
z is a global variable, so it
}
can be used by any function
including main()
1. Does not receive and not return value
2. Receive but does not return any value
3. Receive and return value

Format

function type function_name (parameter_list);

Determine whether Determine whether

function returns a value functions receive a value
 1.Function that does not receive and not return value

Example:
void function1(void);

not return value not receive value

void function2(void);

not return value not receive value

Example:

Prototype: #include <iostream>

void input(); using namespace std;

Call: void input(); //function prototype

input();
int main()
Definition: {
input(); //function call
void input() }
{ cout << “Enter input :”;
cin >>input; //function definition
} void input()
{ cout << “Enter input :”;
cin >>input;
}
 2. Function that receive but does not return any value

Example:
void function1(int);

not return value receives integer value

void function2(int,int);

not return value receives two integer values

void function3(int,float,int);

not return value receives two integers and a float values

 Example 1:

Prototype: #include <iostream>

void function1(int); using namespace std;

Call: void function1(int);

function1(a);
int main()
Definition: { int a ;
cout << “Enter a value:”;
void function1(int a) cin >> a;
{ cout << “Value a is ” << a; } function1(a);
}

void function1(int a)
{ cout << “Value a is ” << a; }
 Example 2:
Prototype: #include <iostream>
using namespace std;
void print_discount(int); void print_discount(int);

Call: int main()

print_discount(quantity); { int quantity;
cout << “Enter quantity : ”;
Definition: cin >> quantity;
void print_discount(int b) print_discount(quantity);
{ if (b > 1000) }
printf(“Discount = 50%”); void print_discount(int b)
else { if (b > 1000)
printf(“Discount = 10%”); cout << “Discount = 50%”;
} else
cout << “Discount = 10%”;
}
 3. Function that receives and returns value

Example:
int function1(int);

returns value receives integer value

float function2(int,int);

returns value receives two integer values

int function3(int,float,int);

returns value receives two integers and a float values

Prototype: #include <iostream>
float calculate_discount(int); using namespace std;
float calculate_discount(int);
Call:
void main()
calculate_discount(kuantiti);
{ int quantity;
cout << “Enter quantity :”;
Definition: cin >> quantity;
cout << “Discount” << calculate_discount(quantity);
float calculate_discount(int b) }
{ if (b > 1000)
discount = 0.5; float calculate_discount(int quantity)
else {
float discount;
discount = 0.1;
if (quantity > 1000)
return discount; discount = 0.5;
} else
discount = 0.1;
return discount;
}
#include<iostream>
using namespace std;
void change1(int);
int change2(int);
int main()
{
int a=5;
int b;
cout << "Before change1: a = " << a << endl;
change1(a);
cout << "After change1: a = " << a << endl;
b=change2(a);
cout << "After change2: a = " << a << " b = " << b << endl;
system("pause");
}

void change1(int a)
{
a=2*a;
cout << "Value of a in change1 function: " << a << endl;
}

int change2(int b)
{
int a;
a=4;
b=a + b;
return (b);
}
Give the function prototype for each of the following:
Function smallest that takes three integers, x, y,
z and returns an integer.
Function instructions that does not receive any
arguments and does not return a value.
Function inToFloat that takes an integer argument,
number, and returns a floating-point result.
#include<stdio.h>
#include <conio.h>
void change1(int);
int change2(int);
int main()
{
int a=5;
int b;
printf("Before change1: a=%d\n",a);
change1(a);
printf("After change1: a=%d\n",a);
b=change2(a);
printf("After change2: a=%d b=%d\n",a,b);
getch();
}

void change1(int a)
{
a=2*a;
printf("Value of a in change1 function: %d\n",a);
}

int change2(int b)
{
int a;
a=4;
b=a + b;
return (b);
}