A First Book of C++

Chapter 7
Arrays
 Objectives

• In this chapter, you will learn about:

– One-Dimensional Arrays
– Array Initialization
– Arrays as Arguments
– Two-Dimensional Arrays
– Common Programming Errors
– Searching and Sorting Methods

A First Book of C++ 4th Edition 2

 One-Dimensional Arrays

• One-dimensional array (single-dimension array or

vector): a list of related values
– All items in list have same data type
– All list members stored using single group name
• Example: a list of grades
98, 87, 92, 79, 85
– All grades are integers and must be declared
• Can be declared as single unit under a common name
(the array name)

A First Book of C++ 4th Edition 3

 One-Dimensional Arrays (cont'd.)

• Array declaration statement provides:

– The array (list) name
– The data type of array items
– The number of items in array
• Syntax
dataType arrayName[numberOfItems]
– Common programming practice requires defining
number of array items as a constant before declaring
the array

A First Book of C++ 4th Edition 4

 One-Dimensional Arrays (cont'd.)

• Examples of array declaration statements:

const int NUMELS = 5; // define a constant

// for the number of
// items
int amts[NUMELS]; // declare the array

const int NUMELS = 4;

char code[NUMELS];

const int SIZE = 100;

double amount[SIZE];

A First Book of C++ 4th Edition 5

 One-Dimensional Arrays (cont'd.)

• Each array allocates sufficient memory to hold the

number of data items given in declaration
• Array element (component): an item of the array
• Individual array elements stored sequentially
– A key feature of arrays that provides a simple
mechanism for easily locating single elements

A First Book of C++ 4th Edition 6

 One-Dimensional Arrays (cont'd.)

A First Book of C++ 4th Edition 7

 One-Dimensional Arrays (cont'd.)

• Index (subscript value): position of individual

element in an array
• Accessing of array elements: done by giving array
name and element’s index
– grade[0] refers to first grade stored in grade array
• Subscripted variables can be used anywhere that
scalar variables are valid:
grade[0] = 95.75;
grade[1] = grade[0] - 11.0;

A First Book of C++ 4th Edition 8

 One-Dimensional Arrays (cont'd.)

A First Book of C++ 4th Edition 9

 One-Dimensional Arrays (cont'd.)

• Subscripts: do not have to be integers

– Any expression that evaluates to an integer may be
used as a subscript
– Subscript must be within the declared range
• Examples of valid subscripted variables (assumes i
and j are int variables):
grade[i]
grade[2*i]
grade[j-i]

A First Book of C++ 4th Edition 10

 Input and Output of Array Values

• Individual array elements can be assigned values

interactively using a cin stream object
cin >> grade[0];
cin >> grade[1] >> grade[2] >> grade[3];
cin >> grade[4] >> prices[6];
• Instead, a for loop can be used
const int NUMELS = 5;
for (int i = 0; i < NUMELS; i++)
{
cout << "Enter a grade: ";
cin >> grade[i];
}

A First Book of C++ 4th Edition 11

 Input and Output of Array Values
(cont'd.)
• Bounds checking: C++ does not check if value of
an index is within declared bounds
• If an out-of-bounds index is used, C++ will not
provide notification
– Program will attempt to access out-of-bounds element,
causing program error or crash
– Using symbolic constants helps avoid this problem

A First Book of C++ 4th Edition 12

 Input and Output of Array Values
(cont'd.)
• Using cout to display subscripted variables:
– Example 1
cout << prices[5];

– Example 2
cout << "The value of element " << i << "
is " << grade[i];

– Example 3
const int NUMELS = 20;
for (int k = 5; k < NUMELS; k++)
cout << k << " " << amount[k];

A First Book of C++ 4th Edition 13

 Input and Output of Array Values
(cont'd.)
• Program example of array I/O (Program 7.1):
#include <iostream>
using namespace std;
int main()
{
const int NUMELS = 5;
int i, grade[NUMELS];
for (i = 0; i < NUMELS; i++) // Enter the grades
{
cout << "Enter a grade: ";
cin >> grade[i];
}
cout << endl;
for (i = 0; i < NUMELS; i++) // Print the grades
cout << "grade [" << i << "] is " << grade[i]
<< endl;
return 0;
}
A First Book of C++ 4th Edition 14
 Input and Output of Array Values
(cont'd.)
• Sample run using Program 7.1:
Enter a grade: 85
Enter a grade: 90
Enter a grade: 78
Enter a grade: 75
Enter a grade: 92

grade[0] is 85
grade[1] is 90
grade[2] is 78
grade[3] is 75
grade[4] is 92

A First Book of C++ 4th Edition 15

 Array Initialization

• Array elements can be initialized within declaration

statements
– Initializing elements must be included in braces
– Example:
const int NUMGALS = 20;
int gallons[NUMGALS] =
{19, 16, 14, 19, 20, 18, // initializing values
12, 10, 22, 15, 18, 17, // can extend across
16, 14, 23, 19, 15, 18, // multiple lines
21, 5};

A First Book of C++ 4th Edition 16

 Array Initialization (cont'd.)

• Size of array may be omitted when initializing values

are included in declaration statement
• Example: the following are equivalent
const int NUMCODES = 6;
char code[6] = {'s', 'a', 'm', 'p', 'l', 'e'};

char code[ ] = {'s', 'a', 'm', 'p', 'l', 'e'};

• Both declarations set aside six character locations
for an array named code

A First Book of C++ 4th Edition 17

 Array Initialization (cont'd.)

• Simplified method for initializing character arrays

char codes[ ] = “sample”;
//no braces or commas
• This statement uses the string “sample” to initialize
the code array
– The array is comprised of seven characters
– The first six characters are the letters:
s, a, m, p, l, e
– The last character (the escape sequence \0) is called
the null character

A First Book of C++ 4th Edition 18

 Array Initialization (cont'd.)

A First Book of C++ 4th Edition 19

 Arrays as Arguments

• Array elements are passed to a called function in

same manner as individual scalar variables
– Example:
findMax(grades[2], grades[6]);
• Passing a complete array to a function provides
access to the actual array, not a copy
– Making copies of large arrays is wasteful of storage

A First Book of C++ 4th Edition 20

 Arrays as Arguments (cont'd.)

• Examples of function calls that pass arrays:

int nums[5]; // an array of five integers

char keys[256]; // an array of 256 characters
double units[500], grades[500];// two arrays of
// 500 doubles
• The following function calls can then be made:
findMax(nums);
findCharacter(keys);
calcTotal(nums, units, grades);

A First Book of C++ 4th Edition 21

 Arrays as Arguments (cont'd.)

• Suitable receiving side function header lines:

int findMax(int vals[5])
char findCharacter(char inKeys[256])
void calcTotal(int arr1[5],
double arr2[500],
double arr3[500])

A First Book of C++ 4th Edition 22

 Arrays as Arguments (cont'd.)

• Example of passing arrays as arguments (Program

7.4):
– Constant MAXELS is declared globally
– Prototype for findMax() uses constant MAXELS to
declare that findMax() expects an array of five
integers as an argument
– As shown in Figure 7.5, only one array is created in
Program 7.4
• In main(), the array is known as nums
• In findMax(), it is known as vals

A First Book of C++ 4th Edition 23

A First Book of C++ 4th Edition 24
 Arrays as Arguments (cont'd.)

A First Book of C++ 4th Edition 25

 Two-Dimensional Arrays

• Two-dimensional array (table): consists of both

rows and columns of elements
• Example: two-dimensional array of integers
8 16 9 52
3 15 27 6
14 25 2 10
• Array declaration: names the array val and
reserves storage for it
int val[3][4];

A First Book of C++ 4th Edition 26

 Two-Dimensional Arrays (cont'd.)

• Locating array elements (Figure 7.7)

– val[1][3] uniquely identifies element in row 1,
column 3
• Examples using elements of val array:
price = val[2][3];
val[0][0] = 62;
newnum = 4 * (val[1][0] - 5);
sumRow = val[0][0] + val[0][1] + val[0][2]
+ val[0][3];
– The last statement adds the elements in row 0 and
sum is stored in sumRow

A First Book of C++ 4th Edition 27

 Two-Dimensional Arrays (cont'd.)

A First Book of C++ 4th Edition 28

 Two-Dimensional Arrays (cont'd.)

• Initialization: can be done within declaration

statements (as with single-dimension arrays)
• Example:
int val[3][4] = { {8,16,9,52},
{3,15,27,6},
{14,25,2,10} };
– First set of internal braces contains values for row 0,
second set for row 1, and third set for row 2
– Commas in initialization braces are required; inner
braces can be omitted

A First Book of C++ 4th Edition 29

 Two-Dimensional Arrays (cont'd.)

• Processing two-dimensional arrays: nested for

loops typically used
– Easy to cycle through each array element
• A pass through outer loop corresponds to a row
• A pass through inner loop corresponds to a column
– Nested for loop in Program 7.7 used to multiply each
val element by 10 and display results
• Output of Program 7.7
Display of multiplied elements
80 160 90 520
30 150 270 60
140 250 20 100
A First Book of C++ 4th Edition 30
 Two-Dimensional Arrays (cont'd.)

• Prototypes for functions that pass two-dimensional

arrays can omit the row size of the array
– Example (Program 7.8):
display (int nums[ ][4]);
– Row size is optional, but column size is required
• The element val[1][3] is located 28 bytes from the
start of the array (assuming 4 bytes for an int)

A First Book of C++ 4th Edition 31

 Two-Dimensional Arrays (cont'd.)

• Determining offset of an array

– Computer uses row index, column index, and column
size to determine offset

A First Book of C++ 4th Edition 32

 Two-Dimensional Arrays (cont'd.)

A First Book of C++ 4th Edition 33

 Larger Dimensional Arrays

• Arrays with more than two dimensions allowed in

C++ but not commonly used
• Example: int response[4][10][6]
– First element is response[0][0][0]
– Last element is response[3][9][5]
• A three-dimensional array can be viewed as a book
of data tables (Figure 7.10)
– First subscript (rank) is page number of table
– Second subscript is row in table
– Third subscript is desired column

A First Book of C++ 4th Edition 34

 Larger Dimensional Arrays (cont'd.)

A First Book of C++ 4th Edition 35

 Common Programming Errors

• Forgetting to declare an array

– Results in a compiler error message equivalent to
“invalid indirection” each time a subscripted variable is
encountered within a program
• Using a subscript that references a nonexistent
array element
– For example, declaring array to be of size 20 and
using a subscript value of 25
– Not detected by most C++ compilers and will probably
cause a runtime error

A First Book of C++ 4th Edition 36

 Common Programming Errors (cont'd.)

• Not using a large enough counter value in a for

loop counter to cycle through all array elements
• Forgetting to initialize array elements
– Don’t assume compiler does this

A First Book of C++ 4th Edition 37

 Summary

• One-dimensional array: a data structure that stores

a list of values of same data type
– Must specify data type and array size
– Example:
int num[100]; creates an array of 100 integers
• Array elements are stored in contiguous locations in
memory and referenced using the array name and a
subscript
– Example: num[22]

A First Book of C++ 4th Edition 38

 Summary (cont'd.)

• Two-dimensional array is declared by listing both a

row and column size with data type and name of
array
• Arrays may be initialized when they are declared
– For two-dimensional arrays, you list the initial values,
in a row-by-row manner, within braces and separating
them with commas
• Arrays are passed to a function by passing name of
array as an argument

A First Book of C++ 4th Edition 39

 Chapter Supplement: Searching and
Sorting Methods
• Most programmers encounter the need to both sort
and search a list of data items at some time in their
programming careers

A First Book of C++ 4th Edition 40

 Search Algorithms

• Linear (sequential) search

– Each item in the list is examined in the order in which
it occurs until the desired item is found or the end of
the list is reached
– List doesn’t have to be in sorted order to perform the
search
• Binary search
– Starting with an ordered list, the desired item is first
compared with the element in the middle of the list
– If item is not found, you continue the search on either
the first or second half of the list

A First Book of C++ 4th Edition 41

EC-102 Computer System &
Programming

Instructor: Jahan Zeb

Department of Computer Engineering (DCE)
College of E&ME
 Functions

 Divide and conquer

– Construct a program from smaller pieces or components
– Each piece more manageable than the original program
 Program Components in C++

 Modules: functions and classes

 Programs use new and “prepackaged” modules
– New: programmer-defined functions,
– Prepackaged: from the standard library
 Functions invoked by function call
– Function name and information (arguments) it needs
 Function definitions
– Only written once
– Hidden from other functions
 Program Components in C++

 Boss to worker analogy

– A boss (the calling function or caller) asks a worker (the
called function) to perform a task and return (i.e., report
back) the results when the task is done.
 Math Library Functions

 Perform common mathematical calculations

– Include the header file <cmath>
 Functions called by writing
– functionName (argument);
or
– functionName(argument1, argument2, …);
 Example
cout << sqrt( 900.0 );
– sqrt (square root) function The preceding statement would
print 30
– All functions in math library return a double
 Math Library Functions

 Function arguments can be

– Constants
• sqrt( 4 );
– Variables
• sqrt( x );
– Expressions
• sqrt( sqrt( x ) ) ;
• sqrt( 3 - 6x );
Method Description Example
ceil( x ) rounds x to the smallest integer not less than x ceil( 9.2 ) is 10.0
ceil( -9.8 ) is -9.0
cos( x ) trigonometric cosine of x cos( 0.0 ) is 1.0
(x in radians)
exp( x ) exponential function ex exp( 1.0 ) is 2.71828
exp( 2.0 ) is 7.38906
fabs( x ) absolute value of x fabs( 5.1 ) is 5.1
fabs( 0.0 ) is 0.0
fabs( -8.76 ) is 8.76
floor( x ) rounds x to the largest integer not greater than floor( 9.2 ) is 9.0
x floor( -9.8 ) is -10.0
fmod( x, y ) remainder of x/y as a floating-point number fmod( 13.657, 2.333 ) is 1.992

log( x ) natural logarithm of x (base e) log( 2.718282 ) is 1.0

log( 7.389056 ) is 2.0
log10( x ) logarithm of x (base 10) log10( 10.0 ) is 1.0
log10( 100.0 ) is 2.0
pow( x, y ) x raised to power y (xy) pow( 2, 7 ) is 128
pow( 9, .5 ) is 3
sin( x ) trigonometric sine of x sin( 0.0 ) is 0
(x in radians)
sqrt( x ) square root of x sqrt( 900.0 ) is 30.0
sqrt( 9.0 ) is 3.0
tan( x ) trigonometric tangent of x tan( 0.0 ) is 0
(x in radians)
 Functions

 Functions
– Modularize a program
– Software reusability
• Call function multiple times
 Local variables
– Known only in the function in which they are defined
– All variables declared in function definitions are local
variables
 Parameters
– Local variables passed to function when called
– Provide outside information
 Function Definitions

 Function prototype
– Tells compiler argument type and return type of function
– int square( int );
• Function takes an int and returns an int

 Calling/invoking a function
– square(x);
– Parentheses an operator used to call function
• Pass argument x
• Function gets its own copy of arguments
– After finished, passes back result
 Function Definitions

 Format for function definition

return-value-type function-name( parameter-list )
{
declarations and statements
}
– Parameter list
• Comma separated list of arguments
– Data type needed for each argument
• If no arguments, use void or leave blank
– Return-value-type
• Data type of result returned (use void if nothing returned)
 Function Definitions

 Example function
int square( int y )
{

return y * y;
}
 return keyword
– Returns data, and control goes to function’s caller
• If no data to return, use return;
– Function ends when reaches right brace
• Control goes to caller
 Functions cannot be defined inside other functions
 Next: program examples
1
2
3 #include <iostream>
4 Function prototype: specifies
5 using std::cout; data types of arguments and
6 using std::endl; return values. square
7
expects an int, and returns
8 int square( int ); // function prototype
an int.
9
10 int main()
11 { Parentheses () cause function
12 // loop 10 times and calculate and output
to be called. When done, it
13 // square of x each time
14 for ( int x = 1; x <= 10; x++ )
returns the result.
15 cout << square( x ) << " "; // function call
16
17 cout << endl;
18
19 return 0; // indicates successful termination
20
21 } // end main
22
23 // square function definition returns square of an integer
24 int square( int y ) // y is a copy of argument to function
25 {
26 return y * y; // returns square of y as an int
27
28 } // end function square
Definition of square. y is a
copy of the argument passed.
1 4 9 16 25 36 49 64 81 100 Returns y * y, or y squared.
1
2 // Finding the maximum of three floating-point numbers.
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 double maximum( double, double, double ); // function prototype
10
11 int main()
12 {
13 double number1;
Function maximum takes 3
14 double number2;
arguments (all double) and
15 double number3;
16
returns a double.
17 cout << "Enter three floating-point numbers: ";
18 cin >> number1 >> number2 >> number3;
19
20 // number1, number2 and number3 are arguments to
21 // the maximum function call
22 cout << "Maximum is: "
23 << maximum( number1, number2, number3 ) << endl;
24
25 return 0; // indicates successful termination
26
27 } // end main
28 Comma separated list for
29 // function maximum definition; multiple parameters.
30 // x, y and z are parameters
31 double maximum( double x, double y, double z )
32 {
33 double max = x; // assume x is largest
34
35 if ( y > max ) // if y is larger,
36 max = y; // assign y to max
37
38 if ( z > max ) // if z is larger,
39 max = z; // assign z to max
40
41 return max; // max is largest value
42
43 } // end function maximum

Enter three floating-point numbers: 99.32 37.3 27.1928

Maximum is: 99.32

Enter three floating-point numbers: 1.1 3.333 2.22

Maximum is: 3.333

Enter three floating-point numbers: 27.9 14.31 88.99

Maximum is: 88.99
 Function Prototypes

 Function prototype contains

– Function name
– Parameters (number and data type)
– Return type (void if returns nothing)
– Only needed if function definition after function call
 Prototype must match function definition
– Function prototype
double maximum( double, double, double );
– Definition
double maximum( double x, double y, double z )
{
…
}
 Function Prototypes

 Function signature
– Part of prototype with name and parameters
• double maximum( double, double, double );
Function signature

 Argument Coercion
– Force arguments to be of proper type
• Converting int (4) to double (4.0)
cout << sqrt(4)
– Conversion rules
• Arguments usually converted automatically
• Changing from double to int can truncate data
– 3.4 to 3
 break and continue Statements

 break statement
– Immediate exit from while, for, do/while, switch
– Program continues with first statement after structure
 Common uses
– Escape early from a loop
– Skip the remainder of switch
1
2 // Using the break statement in a for structure.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 // function main begins program execution
9 int main()
10 {
11
12 int x; // x declared here so it can be used after the loop
13
14 // loop 10 times
15 for ( x = 1; x <= 10; x++ ) { Exits for structure when
16 break executed.
17 // if x is 5, terminate loop
18 if ( x == 5 )
19 break; // break loop only if x is 5
20
21 cout << x << " "; // display value of x
22
23 } // end for
24
25 cout << "\nBroke out of loop when x became " << x << endl;
26
27 return 0; // indicate successful termination
28
29 } // end function main

1 2 3 4
Broke out of loop when x became 5
 break and continue Statements

 continue statement
– Used in while, for, do/while
– Skips remainder of loop body
– Proceeds with next iteration of loop
 while and do/while structure
– Loop-continuation test evaluated immediately after the
continue statement
 for structure
– Increment expression executed
– Next, loop-continuation test evaluated
1
2 // Using the continue statement in a for structure.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 // function main begins program execution
9 int main()
10 {
11 // loop 10 times
12 for ( int x = 1; x <= 10; x++ ) {
13 Skips to next iteration of the
14 // if x is 5, continue with loop.
next iteration of loop
15 if ( x == 5 )
16 continue; // skip remaining code in loop body
17
18 cout << x << " "; // display value of x
19
20 } // end for structure
21
22 cout << "\nUsed continue to skip printing the value 5"
23 << endl;
24
25 return 0; // indicate successful termination
26
27 } // end function main

1 2 3 4 6 7 8 9 10
Used continue to skip printing the value 5
1
2 // Shifted, scaled integers produced by 1 + rand() % 6.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include <iomanip>
9
10 using std::setw;
11
12 #include <cstdlib> // contains function prototype for rand
13
14 int main()
15 {
16 // loop 20 times
Output of rand() scaled and
17 for ( int counter = 1; counter <= 20; counter++ ) {
18
shifted to be a number
19 // pick random number from 1 to 6 and output it between 1 and 6.
20 cout << setw( 10 ) << ( 1 + rand() % 6 );
21
22 // if counter divisible by 5, begin new line of output
23 if ( counter % 5 == 0 )
24 cout << endl;
25
26 } // end for structure
27
28 return 0; // indicates successful termination
29
30 } // end main

6 6 5 5 6
5 1 1 5 3
6 6 2 4 2
6 2 3 4 1
 Storage Classes

 Variables have attributes

– Have seen name, type, size, value
– Storage class
• How long variable exists in memory
– Scope
• Where variable can be referenced in program
– Linkage
• For multiple-file program
 Storage Classes

 Automatic storage class

– Variable created when program enters its block
– Variable destroyed when program leaves block
– Only local variables of functions can be automatic
• Automatic by default
• keyword auto explicitly declares automatic
– register keyword
• Hint to place variable in high-speed register
• Good for often-used items (loop counters)
• Often unnecessary, compiler optimizes
– Specify either register or auto, not both
• register int counter = 1;
 Storage Classes

 Static storage class

– Variables exist for entire program
– May not be accessible, scope rules still apply (more later)
 static keyword
– Local variables in function
– Keeps value between function calls
– Only known in own function
 extern keyword
– Default for global variables/functions
• Globals: defined outside of a function block
– Known in any function that comes after it
 Scope Rules

 Scope
– Portion of program where identifier can be used
 File scope
– Defined outside a function, known in all functions
– Global variables, function definitions and prototypes
 Function scope
– Can only be referenced inside defining function
 Scope Rules

 Block scope
– Begins at declaration, ends at right brace }
• Can only be referenced in this range
– Local variables, function parameters
– static variables still have block scope
• Storage duration does not affect scope
 Function-prototype scope
– Parameter list of prototype
– Names in prototype optional
• Compiler ignores
– In a single prototype, name can be used once
1
2 // A scoping example.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 void useLocal( void ); // function prototype
9
Declared outside of function;
void useStaticLocal( void ); // function prototype
10 void useGlobal( void ); global variable with
// function file
prototype
11 scope.
12 int x = 1; // global variable
13 Local variable with function
14 int main() scope.
15 {
16 int x = 5; // local variable to main
17
18 cout << "local x in main's outer scope
Create is "block,
a new << x giving
<< endl;
x
19
block scope. When the block
20 { // start new scope
ends, this x is destroyed.
21
22 int x = 7;
23
24 cout << "local x in main's inner scope is " << x << endl;
25
26 } // end new scope
27
28 cout << "local x in main's outer scope is " << x << endl;
29
30 useLocal(); // useLocal has local x
31 useStaticLocal(); // useStaticLocal has static local x
32 useGlobal(); // useGlobal uses global x
33 useLocal(); // useLocal reinitializes its local x
34 useStaticLocal(); // static local x retains its prior value
35 useGlobal(); // global x also retains its value
36
37 cout << "\nlocal x in main is " << x << endl;
38
39 return 0; // indicates successful termination
40
41 } // end main
42
43 // useLocal reinitializes local variable x during each call
44 void useLocal( void )
45 {
46 int x = 25; // initialized each time useLocal is called
47
48 cout << endl << "local x is Automatic
" << x variable (local
49 << variable
" on entering useLocal" of function). This
<< endl; is
50 ++x; destroyed when the function
51 cout << "local x is " << x exits, and reinitialized when
52 << the function
" on exiting useLocal" << endl;begins.
53
54 } // end function useLocal
55
56 // useStaticLocal initializes static local variable x only the
57 // first time the function is called; value of x is saved
58 // between calls to this function
59 void useStaticLocal( void )
60 {
61 // initialized only first time useStaticLocal is called
62 static int x = 50;
63
64 cout << endl << "local static x is " << x
65 << " on entering useStaticLocal" << endl;
66 ++x;
67 cout << "local static x is " << xStatic local variable of
68 << function;
" on exiting useStaticLocal" it is initialized
<< endl; only
69 once, and retains its value
70 } // end function useStaticLocal between function calls.
71
72 // useGlobal modifies global variable x during each call
73 void useGlobal( void )
74 {
75 cout << endl << "global x is " << x This function does not declare
76 << " on entering useGlobal" << endl; any variables. It uses the
77 x *= 10; global x declared in the
78 cout << "global x is " << x
beginning of the program.
79 << " on exiting useGlobal" << endl;
80
81 } // end function useGlobal

local x in main's outer scope is 5

local x in main's inner scope is 7
local x in main's outer scope is 5

local x is 25 on entering useLocal

local x is 26 on exiting useLocal

local static x is 50 on entering useStaticLocal

local static x is 51 on exiting useStaticLocal

global x is 1 on entering useGlobal

global x is 10 on exiting useGlobal
local x is 25 on entering useLocal
local x is 26 on exiting useLocal

local static x is 51 on entering useStaticLocal

local static x is 52 on exiting useStaticLocal

global x is 10 on entering useGlobal

global x is 100 on exiting useGlobal

local x in main is 5
 Functions with Empty Parameter Lists

 Empty parameter lists

– void or leave parameter list empty
– Indicates function takes no arguments
– Function print takes no arguments and returns no value
• void print();
• void print( void );
1
2 // Functions that take no arguments.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 void function1(); // function prototype
9 void function2( void ); // function prototype
10
11 int main()
12 {
13 function1(); // call function1 with no arguments
14 function2(); // call function2 with no arguments
15
16 return 0; // indicates successful termination
17
18 } // end main
19
20 // function1 uses an empty parameter list to specify that
21 // the function receives no arguments
22 void function1()
23 {
24 cout << "function1 takes no arguments" << endl;
25
26 } // end function1
27
28 // function2 uses a void parameter list to specify that
29 // the function receives no arguments
30 void function2( void )
31 {
32 cout << "function2 also takes no arguments" << endl;
33
34 } // end function2

function1 takes no arguments

function2 also takes no arguments
WELCOME TO YOUR
PRESENTATION

Topic Name : Built in Function

PRESENTED BY

Group Member ID
Tania Akter 0111-61-035
MD. Rayhanul Islam 0111-61-036
Saddam Hossain 0111-61-037
FUNCTION :
 A function is a group of statements that together perform
a task.

 A function is a block of code that performs a calculation

and returns a value.

 Every C program has at least one function, which

is main()
CLASSIFICATION OF FUNCTION :
Function

User define Library function

function or Built-in function
WHAT IS LIBRARY FUNCTION OR
BUILT-IN FUNCTION??
 Built in functions are the functions that are provided by
C library.

 These functions perform file access, mathematical

computations, graphics, memory management etc.

 Defined in a special header file.

 A function that is built into an application and can be

accessed by end-users.
BUILT-IN FUCTION HEADER FILES:
<stdio.h> : Standard input/output.

<conio.h> : This is console input/output header file.

<string.h> : All string related functions are defined in

this header file.

<math.h> : All maths related functions are defined

in this header file

<time.h> : Time and clock related functions

<STDIO.H> LIBRARY FUNCTIONS SOURCE CODE :
printf() : This function is used to print the character,
string, float, integer, octal and hexadecimal values onto
the output screen.

scanf() : This function is used to read a character,

string, numeric data from keyboard.

getc() : It reads character from file

gets() : It reads line from keyboard

getchar() : It reads character from keyboard

putchar() : It writes a character to screen
getw() : reads an integer from file

putw() : writes an integer to file

fgetc() : reads a character from file

putc() : writes a character to file

feof() : finds end of file

fprintf() : writes formatted data to a file

fscanf(): reads formatted data from a file

fgetchar : reads a character from keyboard

Fputchar : writes a character from keyboard

<CONIO.H> LBRARY FUNCTIONS SOURCE CODE :

clrscr() : This function is used to clear the output

screen.

getch() : It reads character from keyboard

textcolor() : This function is used to change the

text color

textbackground() : This function is used to

change text background
<STRING.H> LIBRARY FUNCTIONS SOURCE CODE:
strcat(str1, str2) : Concatenates str2 at the end of str1.

strcpy(str1, str2) : Copies str2 into str1

strlen(strl) : gives the length of str1.

strcmp(str1, str2) : Returns 0 if str1 is same as

str2. Returns <0 if strl < str2. Returns >0 if str1 > str2.

strdup() : duplicates the string

strlwr() : converts string to lowercase

<MATH.H> LIBRARY FUNCTIONS SOURCE CODE :

sin( ) : This function is used to calculate sine value.

cos( ) : This function is used to calculate cosine.

tan( ) : This function is used to calculate tangent.

log( ) : This function is used to calculates natural

logarithm.

pow( ) : This is used to find the power of the given

number.
<TIME.H> LIBRARY FUNCTIONS SOURCE CODE :

setdate() : This function used to modify the system date

getdate() : This function is used to get the CPU time

clock() : This function is used to get current system time

time() : This function is used to get current system time

as structure

difftime() : This function is used to get the difference

between two given times
ADVANTAGES :
 It helps in making the code very simple and much
more easier to handle.

 A function may be used by many other programs.

 You can use it over and over without retyping the

code

 Less code for more

 Helps organize your code

DISADVANTAGES:
 I think functions are sometimes difficult to handle
and can confuse the programmer in handling
different tasks.
PROGRAMING IN BUILT-IN FUNCTION :
#include<stdio.h>
main()
{
printf ("Welcome To Your Presentation");
}
Sample Output :
THANK YOU