85ec7 session2 c++

Session – 2
Module-2
Prepared by - Neetu Gupta

Contents
• Control Statements
– break, continue, switch, goto
• Functions
- arguments
- return type
• Scope – global & local scope
• Scope operator
• Storage classes –
auto, register, extern, static

Contents
• Inline functions
• Default arguments
• Enumerations
• Runtime stack
• Command line arguments
• Recursion

break statement
• Using break we can leave a loop even if the
condition for its end is not fulfilled.
• It can be used to end an infinite loop, or to
force it to end before its natural end.
• The format is
break;

break statement - Example
// break loop example
#include <iostream>
using namespace std;
int main () {
int n;
for (n=10; n>0; n--) {
cout << n << ", ";
if (n==3) {
break;
}
}
return 0;
}

• In this example, we are going to stop the
count down before its natural end. The loop
should executes till n is 0. But we are using
break when n is 3. That means loop will not
executes further when n becomes 3.
Hence the output is
10, 9, 8, 7, 6, 5, 4, 3

Please note that 2,1 is not printed as the loop is
break when n = 3.

continue statement
• The continue statement causes the program
to skip the rest of the loop in the current
iteration as if the end of the statement block
had been reached, causing it to jump to the
start of the following iteration. The format is
simple as
continue;

continue statement - Example
// continue loop example
#include <iostream>
int main () {
for (int n=10; n>0; n--)
{
if (n==5)
continue;
cout << n << ", ";
}
return 0;
}

continue statement - Example
• Output is
10, 9, 8, 7, 6, 4, 3, 2, 1

In the example, a for loop is used to print values
from 10 to 1. But here we check if n==5, then we
use continue. hence, the control goes back to
start of for loop and statement the prints n is
skipped.
So the value 5 is not printed in the output above.

goto statement
• The goto allows to make an absolute jump to
another point in the program.
• You should use this feature with caution since its
execution causes an unconditional jump ignoring
any type of nesting limitations.
• The destination point is identified by a label,
which is then used as an argument for the goto
statement.
goto label;

goto statement
// goto loop example
#include <iostream>
int main () {
int n=10;
loop: cout << n << ", ";
n--;
if (n>0) goto loop; // loop is label here
return 0;
}

goto statement
• Output is
10, 9, 8, 7, 6, 5, 4, 3, 2, 1
Here, the loop is created using goto statement.
We check the value of n. If it is > 0, we executes
statement goto loop, this makes the control is
transferred to statement labeled as loop

switch statement
• Its objective is to check several possible constant values for an
expression. Syntax is as:
switch (expression) {
case constant1:
group of statements 1;
break;
case constant1:
group of statements 1;
break;
...
default:
default group of statements
}

switch statement
• It works in the following way:
• switch evaluates expression and
• checks if it is equivalent to constant1, if it is, it executes group of
statements 1 until it finds the break statement. When it finds this
break statement the program jumps to the end of the switch.
• If expression was not equal to constant1 it will be checked against
constant2. If it is equal to this, it will execute group of statements 2
until a break keyword is found, and then will jump to the end of the
switch.
• Finally, if the value of expression did not match any of the
previously specified constants , the program will execute the
statements included after the default: label, if it exists (since it is
optional).

switch statement - Example
// goto loop example
#include <iostream>
int main () {
int x
cout << “ Enter the value of X: ";
cin >> X;
switch (x) {
case 1:
cout << "x is 1";
break;
case 2:
cout << "x is 2";
break;
default:
cout << "value of x unknown";
}

switch statement - Example
• In the example, the value of X is read. Switch
checks the value of X with every case. If the
value of X is 1, then case 1 is executed. If the
value of X is 2 case 2 is executed. Otherwise
the default case is executed.

• Output is
Enter the value of X: 2
X is 2

Function
• Function is a self contained block of statements that
perform a coherent task of some kind.
• Functions make the programs more modular and easy
to read and manage.
• All C++ programs must contain atleast one function i.e.,
main( ), from which the execution of a program starts
• Functions separate the concept (what is done) from the
implementation (how it is done).
• Functions make programs easier to understand.

Function definition
• Before we use a function in main() function of a
program, the function must be properly defined.
• A function definition consists of two parts:
1. function prototype and
2. function body
• Once define a function can be called several times
in the same program, allowing the code to be
reused.

Function prototype
• The prototype specifies how a function can be used/called. It
basically tells the signature of a function
• A function prototype consists of three parts:

• name : This is simply a unique identifier.
• parameters : This is a set of zero or more typed identifiers
used for passing values to and from the function.
• return type: This specifies the type of value the function
returns. A function which returns nothing should have the
return type void.

Function body
• The body of a function contains the computational
steps (statements) that comprise the function i.e. the
code of the function that will get executed when a
function is called.

• The body of the function is return after its prototype
between the curly braces {}.

• The last line in a function body is usually a return
statement.

A simple function - Example
// add two numbers - EXAMPLE
int addition (int a , int b) {
int sum;
sum = a + b;
return sum;
}

Here, addition is a function that adds two integer nos.:
• int addition (int a , int b) – function prototype, which tells
1. function name is – addition
2. parameters are two int values – a & b here
3. return type is an int value – sum here

A simple function – Example contd..
• Function body : the code between {} is the body of
the function
{
int sum;
sum = a + b;
return sum;
}
• Here, the code uses the parameters a and b. It adds the
value of a & b using + operator and saves the result into int
variable sum.
• The value of int type variable sum is returned.

Using a function
• After definition a function should be called in a
program to use it.
• A function call consists of the function name
followed by the call operator brackets ‘()’, inside
which zero or more comma-separated arguments
appear.
• The values passed between (), are called arguments
which are passed to parameters mentioned in
function prototype.

• The following code depicts that how the addition function can
be called in main()
// function call - example
#include <iostream>
int main () {
int x, y;
x = 10;
y = 45;
// Call the function addition with arguments x and y.
int add = addition (x , y);
cout << “Sum of two nos” << x <<“and” << y <<“is” << add;
return 0;
}
Here,
• x and y are arguments which are used to pass the value into parameters a
and b
• The variable add saves the return value from the function addition.

Types Of Function
• In C++, we can basically use/call two types of functions:
2. Standard Library Functions
• These are also called inbuilt functions that are already defined in
various header files we #include in our program.
• The code of these functions is in .lib files of C++
• For e.g.- getch() is defined in file <conio.h>

3. User Defined Functions
• These are the functions which a user defines and provide code.
• Like a function addition that we define in our previous example.

User Defined Function
These are of Four type
• No Arguments No return
• No Arguments but Return
• Arguments but No return
• Arguments with Return

No Arguments No Return
• Neither the main function pass any value nor the called
function return any value
// Example - No Arguments No Return function
#include<conio.h>
void fact(); function prototype

void main()
{
fact(); function calling
)

void fact()
{ int i,n,fact=1;
cout<<“Enter Number”;
cin>>n;
for(i=n;i>0;i--)
fact=fact*i;
cout<<fact;
getch();
}

No Arguments But Return
• A main function doesn’t pass any value to a called
function but called function must return a value to main
function.
// Example - No Arguments But Return
int fact(); function prototype

void main()
{
int f;
f=fact(); function calling no arguments but it will gat a returned value
cout<<f;
}

int fact()
{ int i,fact=1,n;
cin>>n;
for(i=n;i>0;i--)
fact=fact*i;
return fact;
}

Arguments But No Return
• A main function will send arguments to the called
function and called function doesn't return any value to
main ().
// Example - Arguments But no Return
Void fact ( int ); function prototype
Void main()
{ int n;
cin>>n;
fact(n); function calling with a single argument
}
Void fact(int x) a copy of actual argument copies into formal argument x
{ int fact=1,I;
for(i=x;i>0;i--)
fact=fact*I Function Definition
cout<<fact;
}

Arguments With Return
• The main function send values to a calling function and
called function must return value to main function back.
// Example - Arguments with Return
void fact(int); function prototype

void main()
{ int n,f;
cin>>n;
f=fact(n); function calling with a single argument
cout<<f;
}

void fact(int x) a copy of actual argument copies into formal argument x
{ int fact=1,i;
for(i=x;i>0;i--)
fact=fact*I Function Definition
return fact;
}

Scope
• All the variables that we intend to use in a program must have
been declared with its type specifier in an earlier point in the
code, like we did in the previous code at the beginning of the
body of the function main when we declared that a, b, and
result were of type int.

• The scope of a variable tells that where a particular identifier
can be used with in a program and where it can not be used.
• Mainly two types
Global Scope
Local Scope

Global Scope
• Everything defined at the program scope level
(i.e., outside any functions and classes) is said to
have a global scope.
• A global variable is a variable declared in the main
body of the source code, outside all functions.
• Global variables can be referred from anywhere in
the code, even inside functions, whenever it is
after its declaration.

Global Scope - Example
• Variables may also be defined at the global scope.
Below, year is a global variable which can be used in
max() function and main() function
int year = 1994; // global variable
int max (int, int); // global function
int main (void) // global function
{
//...
}
int max (int, int) {
// body of function Max
…..
….
}

Local Scope
• A local variable is one declared within the body of
a function or a block
• The scope of local variables is limited to the block
enclosed in braces ({}) where they are declared.
• A local variable can not be accessed outside its
block.
• A local scope overrides the global scope i.e.
having a local variable with the same name as a
global variable makes the latter inaccessible to
the local scope.

Local Scope
• Each block in a program defines a local scope. Thus the body of a
function represents a local scope. The parameters of a function
have the same scope as the function body.

int xyz; // This xyz is global
void Foo (int xyz) // This xyz is local to the body of Foo
{
if (xyz > 0) {
double xyz; // This xyz is local to this block
//...
}
}

• A complete program could be something like
as below :

Scope Operator
• A local scope overrides the global scope, having a
local variable with the same name as a global
variable makes the latter inaccessible to the local
scope. For example,
int error = 10;
void Error (int error)
{
error = 15;
cout << error; // This will always print 15
}

• Here, the global variable error is inaccessible inside Error
function , because it is overridden by the local error
parameter.
• cout in function Error will always print value 15 not 10.

Scope Operator
• What if at places in a program, we wish to refer
to the variable error which is defined outside not
the variable error which is defined inside
function.
• This problem is overcome using the unary scope
operator
• A scope operator is written as ::
• It takes a global entity as argument.

Scope Operator - Example
// Use of Scope operator ::
int error = 10;
void Error (int error)
{
error = 15;
cout << “Local error is:” << error; // Local - will always print 15
cout << “ Global error is:” << ::error; // Global - This will print 10
}

Output will be
Local error is:15
Global error is:10

Storage Classes
• The "storage class" of a variable determines
The determines the part of member storage is
allocated for an object and how long the
storage allocation continues to exit. It tells
a.Where the variable is stored.
b.Initial value of the variable.
c.Scope of the variable. Scope specifies the
part of the program which a variable is
accessed global or local scope
d.Life of the variable.

• There are four types of storage classes in C+
+ which it inherits from C:
1. Automatic storage class
2. Register storage class
3. Static storage class
4. External storage class

Auto Variable
• The lifetime of a local variable is limited and is
determined automatically, these variables are
also called automatic.
• In this automatic storage class, variable is stored in
memory.
• Default value is garbage value
• Scope is local to the block
• Life is, with in the block in which the variable is defined
• Variable is defined using keyword auto
auto int I;

// auto variable – Example
#include <iostream>
main()
{
auto int i;
auto int j = 100;
cout >> “j is:” >> i
cout >> “j is:” >> j
}

Output:
I is: 2000
J is: 10

• Here I is not initialized any value so it print say value
like 2000 here, whereas j has the value 10 as
initialized

Register Variable
• The storage class specifier register may be used
to indicate to the compiler that the variable
should be stored in a register if possible.
• Variable is stored in CPU registers.
• Default value is garbage value.
• Scope is local to the block.
• Life is, with in the block in which the variable is defined.
• We can not use register storage class for all types of variables.
• These are used for fast retrieval.
• Variable is defined using keyword register
register int I;

// register variable – Example
#include <iostream>
main()
{
for (register int i = 0; i < n; ++i)
sum += i;
}

• Here, each time round the loop, i is used three times:
once when it is compared to n, once when it is added
to sum, and once when it is incremented. Therefore
it makes sense to keep i in a register for the duration
of the loop.

Static Variable
• Defining a variable simply means that once the
variable has been initialized, it remains in
memory until the end of the program.
• Variable is stored in memory.
• Default value is zero.
• Life is, value of the variable persists between different
function calls.
• Variable is defined using keyword static
static int I;

// STATIC variable – Example
#include <iostream>
main()
{
add();
add();
}

// Function definition
add()
{
static int i=10; // i static variable defined
cout << “ I is ::” << I;
i+=1;
}

Output:
I is :: 10
I is :: 11

• Here, in function add() I is initialized to 10. so first time 10 is printed. In the second call to
add() function in main(), the value of I is preserved as it is defined as static. So the value
printed I is 11 not 10.

Extern Variables
• A global variable may be defined in one file and
referred to in other files, some means of telling the
compiler that the variable is defined elsewhere may
be needed. This is facilitated by an extern declaration.
• Variable is stored in memory.
• Default value is zero.
• Life is, as long as the program execution doesn’t come to an end.
• Declared using keyword extern as
extern int size; // variable declaration
This informs the compiler that size is actually defined somewhere (may be later in this file or in another file)..

• // extern class – Example
File 1: main.c
int count=5;
main() {
write_extern();
}

File 2: write.c

void write_extern(void);
extern int count;
void write_extern(void) {
cout >> "count is n“ >> count;
}

Here extern keyword is being used to declare count in another file.

Enumerations
• An enumeration consists of a set of named integer
constants.
• An enumeration type declaration gives the name of
the (optional) enumeration tag and defines the set of
named integer identifiers (called the "enumeration
set," "enumerator constants”).
• A variable with enumeration type stores one of the
values of the enumeration set defined by that type.
• Variables of enum type can be used in indexing
expressions and as operands of all arithmetic and
relational operators.

Enumerations - Use
• Syntax to declare an enum is

enum identifier { enumerator-list } ;

// Defines an enumeration type named as DAY
enum DAY
{
saturday,
sunday = 0,
monday,
wednesday
thursday,
friday
};

• The first value starts with 0 by default so value 0 is associated with saturday by
default.
• The identifier sunday is explicitly set to 0. The remaining identifiers are given the
values 1 through 5 by default in sequence.

• A variable today of type DAY can be declared
and initialized as
enum DAY today = wednesday;
In this example, a value from the set DAY is assigned to the variable today.

• To explicitly assign an integer value to a
variable of an enumerated data type, use a
type cast:
enum DAY workday = ( enum DAY ) ( day_value - 1 );

// Enum example

#include <stdio.h>
int main()
{
// declare a enum Days
enum Days {Sunday,
Monday,Tuesday,
Wednesday,Thursday,
Friday,Saturday
};
Days TheDay; // a variable of type Days
int j = 0;
cout >> “Please enter the day of the week (0 to 6)n";
cin << theDay;
TheDay = Days(j);
if(TheDay == Sunday || TheDay == Saturday)
printf("Hurray it is the weekendn");
else
printf("Curses still at workn");
return 0;
}

Recursion
• A function which calls itself is said to be a
recursive function and the process is called
recursion.
• It is useful for many tasks, like sorting or
calculate the factorial of numbers
• There should always be an exit condition to
end the recursion otherwise the call to
function might go in as a infinite loop.
(Important !!)

Recursion - Example
• A function that calculates the factorial of a
number n - the mathematical formula is n! =
n * (n-1) * (n-2) * (n-3) ... * 1
like if n = 5
5! = 5 * 4 * 3 * 2 * 1 = 120

• The task to be done for this is recursive in
nature , hence we can apply recursion as

// factorial calculator - Example
#include <iostream>

long factorial (long a) {
if (a > 1) // exit condition tested
return (a * factorial (a-1));
else
return (1);
}
int main () {
long number, fact;
cout << "Please type a number: ";
cin >> number;
facto = factorial (number);
cout << “n” << number << "! = " << fact;
return 0;
}
Output is
Please type a number: 5
5! = 120

• Notice how in function factorial we included a call to itself, but only if the argument passed
was greater than 1, since otherwise the function would perform an infinite recursive loop in
which once it arrived to 0 it would continue multiplying by all the negative numbers.

• For n set to 3, this table provides a trace of the calls to
Factorial. The stack frames for these calls appear
sequentially on the runtime stack, one after the other.

Call n n==0 n*factorial(n-1) Return
First 3 0 3*factorial(2) 6
Second 2 0 2*factorial(1) 2
third 1 0 1*factorial(0) 1
Fourth 0 1 1

• A recursive function must have at least one termination
condition which can be satisfied. Otherwise, the function
will call itself indefinitely until the runtime stack
overflows.

Default arguments
• When declaring a function we can specify a default
value for each of the last parameters.
• Default argument is a programming convenience which
removes the burden of having to specify argument
values for all of a function’s parameters.
• If a value for that parameter is not passed when the
function is called, the default value is used, but if a
value is specified this default value is ignored and the
passed value is used instead.

// default values in functions
#include <iostream>
// In function divide, the default value of b is 2
int divide (int a, int b=2) {
int r;
r=a/b;
return (r);
}
int main () {
cout << divide (12) << “n”;
cout << divide (20,4);
return 0;
}
Output is
65

• As we can see in the body of the program there are two calls to function
divide.

In the first one: divide (12)
we have only specified one argument, but the function divide allows up to
two. So the function divide has assumed that the second parameter is 2
since that is what we have specified to happen if this parameter was not
passed (notice the function declaration, which finishes with int b=2, not
just int b). Therefore the result of this function call is 6 (12/2).

In the second call: divide (20,4)
There are two parameters, so the default value for b (int b=2) is ignored
and b takes the value passed as argument, that is 4, making the result
returned equal to 5 (20/4).

Command Line Arguments
• Command-line arguments are given after the name
of a program in command-line operating systems like
DOS or Linux, and are passed in to the program from
the operating system.
• In C it is possible to accept command line arguments
by a program which is being passed to main()
function by operating system.
• For this we must first understand the full declaration
of the main() function

• The full declaration of main looks like this:
int main ( int argc, char *argv[] )

Two parameters are passed into function main()

• argc : An integer type parameter
• It is the argument count. It is the number of arguments passed into the
program from the command line, including the name of the program.

• argv : The array of character pointers

• It is the listing of all the arguments. argv[0] is the name of the program,
or an empty string if the name is not available. After that, every element
number less than argc is a command line argument. You can use each
argv element just like a string, or use argv as a two dimensional array.
argv[argc] is a null pointer.

Command Line Arguments – How to
use them?
• Almost any program that wants its parameters to be
set when it is executed would use this.
• One common use is to write a function that takes the
name of a file and outputs the entire text of it onto
the screen. Suppose the program is saved with name
myfile.cpp
• To pass arguments to main() of this program, we will
execute the program as
myfile <<name of the file>>

// Use of command line arguments – Example
#include <stdio.h>
int main ( int argc, char *argv[] ) {
if ( argc != 2 ) /* argc should be 2 for correct execution */
{
/* We print argv[0] assuming it is the program name */ printf( "usage: %s filename",
argv[0] );
}
else {
// We assume argv[1] is a filename to open
FILE *file = fopen( argv[1], "r" );
/* fopen returns 0, the NULL pointer, on failure */
if ( file == 0 ) {
cout >> "Could not open filen" ;
}
else
{
int x;
/* read one character at a time from file, stopping at EOF, which indicates the end of
the file. Note that the idiom of "assign to a variable, check the value" used below
works because the assignment statement evaluates to the value
assigned. */

while ( ( x = fgetc( file ) ) != EOF ) {
printf( "%c", x );
}
fclose( file );
}
}
}
Explanation:
• It first checks to ensure the user added the second argument,
theoretically a file name. The program then checks to see if
the file is valid by trying to open it. This is a standard
operation, and if it results in the file being opened, then the
return value of fopen will be a valid FILE*; otherwise, it will be
0, the NULL pointer. After that, we just execute a loop to print
out one character at a time from the file.

Inline functions
• The point of making a function inline is to hint to the compiler
that it is worth making some form of extra effort to call the
function faster than it would otherwise - generally by
substituting the code of the function into its caller.

• This does not change the behavior of a function itself, but is
used to suggest to the compiler that the code generated by
the function body is inserted at each point the function is
called, instead of being inserted only once and perform a
regular call to it, which generally involves some additional
overhead in running time.

• Format
The format for its declaration is:
inline type name ( arguments ... )
{
instructions
...
}

The function prototype is simply prefixed by keyword inline

• Call to an inline function

name()

Call is just like the call to any other function. You do not have to include
the inline keyword when calling the function

Motivation for inline functions
• Inline expansion is used to eliminate the time
overhead when a function is called.
• It is typically used for functions that execute
frequently. It also has a space benefit for very small
functions, and is an enabling transformation for
other optimizations.
• Without inline functions, however, the compiler
decides which functions to inline.
• The programmer has little or no control over which
functions are inlined and which are not.
• Giving this degree of control to the programmer
allows for the use of application-specific knowledge
in choosing which functions to inline.

Macros V/S inline
Traditionally, in languages such as C, inline expansion was accomplished at
the source level using parameterized macros.

• Macro invocations do not perform type checking, or even check that
arguments are well-formed, whereas function calls usually do.
• In C, a macro cannot use the return keyword with the same meaning as a
function would do (it would make the function that asked the expansion
terminate, rather than the macro). In other words, you cannot make the
macro return something which is not the result of the last expression
invoked inside it.
• Since C macros use mere textual substitution, this may result in
unintended side-effects and inefficiency due to re-evaluation of
arguments and order of operations.

Macros V/S inline
• Compiler errors within macros are often difficult to
understand, because they refer to the expanded
code, rather than the code the programmer typed.
• Many constructs are awkward or impossible to
express using macros, or use a significantly different
syntax. Inline functions use the same syntax as
ordinary functions, and can be inlined and un-inlined
at will with ease.
• Debugging information for inlined code is usually
more helpful than that of macro-expanded code.

Run time Stack
• Like many other modern programming languages, C+
+ function call execution is based on a runtime stack.
• When a function is called, memory space is allocated
on this stack for the function parameters, return
value, and local variables, as well as a local stack area
for expression evaluation.
• The allocated space is called a stack frame. When a
function returns, the allocated stack frame is
released so that it can be reused.

• Program execution begins at the start of the main
function, of course.
• The main function in this program has variables
Length, Width, Area, and Perim.
• Space is saved for these variables in an area of main
memory called the run-time stack.
• Section of the run-time stack for the main function is
shown below.

• Note that there is more room available at the top end of this stack should
we need it. Since the main function begins by assigning values to variables
Length and Width, these values are shown in the drawing of the run-time
stack.

Next, the main function calls the FindArea function as follows:
FindArea(Length, Width, Area);

• The variables Length, Width, and Area inside these parentheses are the
actual parameters. They correspond in order from left to right to the
three formal parameters found in the code for the function, shown below.

void FindArea(float Length, float Width, float & Area)
{
Area = Length * Width;
}

• When a function call is reached, a stack frame is placed on the run-time
stack.

• We will use a simplified picture of a stack frame that ignores
some of the technical details.
• In our picture, the first item in the stack frame is the return
address, that is, the location in the code to return to when
the called function has completed.
• In our example, program execution should continue on the
line following the function call. Since this return address is a
number indicating a location in the compiled machine code,
no attempt is made to show the number itself, as it will vary
from computer to computer and may even vary from one run
to another on the same computer.
• The next items put into the stack frame are the
parameters. The last items would be local variables,
but our example has none

• The first two formal parameters are non-reference (call-by-copy)
parameters. Thus, in the picture of the run-time stack below, you see that
the 3.4 and 1.2 have been copied into these formal parameters. The third
formal parameter, Area, is a reference parameter. No value is stored in a
reference parameter. Rather, it contains a pointer to the corresponding
actual parameter. In our example the formal parameter Area contains a
pointer to the variable also called Area in the main function section of the
stack. The pointer is essentially the main memory address of the item
pointed to, but is more conveniently drawn as an arrow instead of a
number.

85ec7 session2 c++

More Related Content

What's hot (19)

Similar to 85ec7 session2 c++ (20)

More from Mukund Trivedi (20)

Recently uploaded (20)

85ec7 session2 c++