SlideShare ist ein Scribd-Unternehmen logo
1 von 75
Downloaden Sie, um offline zu lesen
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>
using namespace std;
  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>
using namespace std;
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>
using namespace std;
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>
using namespace std;
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;
  cout<<“Enter Number”;
  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;
      cout<<“Enter Number”;
    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;
       cout<<“Enter Number”;
  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>
using namespace std;
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>
using namespace std;
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.
     •   Scope is local to the block.
     •   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>
using namespace std;
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.
         •     Scope is local to the block.
         •     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>
using namespace std;

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>
using namespace std;
// 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.

Weitere ähnliche Inhalte

Was ist angesagt? (19)

Unit 8
Unit 8Unit 8
Unit 8
 
predefined and user defined functions
predefined and user defined functionspredefined and user defined functions
predefined and user defined functions
 
RECURSION IN C
RECURSION IN C RECURSION IN C
RECURSION IN C
 
Function in C++
Function in C++Function in C++
Function in C++
 
Function overloading
Function overloadingFunction overloading
Function overloading
 
Python functions
Python functionsPython functions
Python functions
 
Chapter 11 Function
Chapter 11 FunctionChapter 11 Function
Chapter 11 Function
 
Function
FunctionFunction
Function
 
C++ Function
C++ FunctionC++ Function
C++ Function
 
Function overloading(C++)
Function overloading(C++)Function overloading(C++)
Function overloading(C++)
 
Parameter passing to_functions_in_c
Parameter passing to_functions_in_cParameter passing to_functions_in_c
Parameter passing to_functions_in_c
 
Functions in C++
Functions in C++Functions in C++
Functions in C++
 
03 function overloading
03 function overloading03 function overloading
03 function overloading
 
Function in C
Function in CFunction in C
Function in C
 
user defined function
user defined functionuser defined function
user defined function
 
Functions in C++
Functions in C++Functions in C++
Functions in C++
 
Functions in python
Functions in pythonFunctions in python
Functions in python
 
Functions
FunctionsFunctions
Functions
 
Recursive Function
Recursive FunctionRecursive Function
Recursive Function
 

Ähnlich wie 85ec7 session2 c++

Function in C++, Methods in C++ coding programming
Function in C++, Methods in C++ coding programmingFunction in C++, Methods in C++ coding programming
Function in C++, Methods in C++ coding programmingestorebackupr
 
Object oriented programming system with C++
Object oriented programming system with C++Object oriented programming system with C++
Object oriented programming system with C++msharshitha03s
 
(3) cpp procedural programming
(3) cpp procedural programming(3) cpp procedural programming
(3) cpp procedural programmingNico Ludwig
 
02 functions, variables, basic input and output of c++
02   functions, variables, basic input and output of c++02   functions, variables, basic input and output of c++
02 functions, variables, basic input and output of c++Manzoor ALam
 
Function in C Programming
Function in C ProgrammingFunction in C Programming
Function in C ProgrammingAnil Pokhrel
 
Python programming variables and comment
Python programming variables and commentPython programming variables and comment
Python programming variables and commentMalligaarjunanN
 
358 33 powerpoint-slides_2-functions_chapter-2
358 33 powerpoint-slides_2-functions_chapter-2358 33 powerpoint-slides_2-functions_chapter-2
358 33 powerpoint-slides_2-functions_chapter-2sumitbardhan
 
Esoft Metro Campus - Programming with C++
Esoft Metro Campus - Programming with C++Esoft Metro Campus - Programming with C++
Esoft Metro Campus - Programming with C++Rasan Samarasinghe
 
CH.4FUNCTIONS IN C (1).pptx
CH.4FUNCTIONS IN C (1).pptxCH.4FUNCTIONS IN C (1).pptx
CH.4FUNCTIONS IN C (1).pptxsangeeta borde
 

Ähnlich wie 85ec7 session2 c++ (20)

Function in C++, Methods in C++ coding programming
Function in C++, Methods in C++ coding programmingFunction in C++, Methods in C++ coding programming
Function in C++, Methods in C++ coding programming
 
Object oriented programming system with C++
Object oriented programming system with C++Object oriented programming system with C++
Object oriented programming system with C++
 
Chap 5 c++
Chap 5 c++Chap 5 c++
Chap 5 c++
 
Chap 5 c++
Chap 5 c++Chap 5 c++
Chap 5 c++
 
Functions in C++.pdf
Functions in C++.pdfFunctions in C++.pdf
Functions in C++.pdf
 
Function
FunctionFunction
Function
 
(3) cpp procedural programming
(3) cpp procedural programming(3) cpp procedural programming
(3) cpp procedural programming
 
C language
C languageC language
C language
 
C++ Language
C++ LanguageC++ Language
C++ Language
 
02 functions, variables, basic input and output of c++
02   functions, variables, basic input and output of c++02   functions, variables, basic input and output of c++
02 functions, variables, basic input and output of c++
 
Function in C Programming
Function in C ProgrammingFunction in C Programming
Function in C Programming
 
Python programming variables and comment
Python programming variables and commentPython programming variables and comment
Python programming variables and comment
 
Functions
FunctionsFunctions
Functions
 
358 33 powerpoint-slides_2-functions_chapter-2
358 33 powerpoint-slides_2-functions_chapter-2358 33 powerpoint-slides_2-functions_chapter-2
358 33 powerpoint-slides_2-functions_chapter-2
 
Programming in Arduino (Part 2)
Programming in Arduino  (Part 2)Programming in Arduino  (Part 2)
Programming in Arduino (Part 2)
 
Esoft Metro Campus - Programming with C++
Esoft Metro Campus - Programming with C++Esoft Metro Campus - Programming with C++
Esoft Metro Campus - Programming with C++
 
Lecture 2
Lecture 2Lecture 2
Lecture 2
 
Introduction to C ++.pptx
Introduction to C ++.pptxIntroduction to C ++.pptx
Introduction to C ++.pptx
 
Functions-.pdf
Functions-.pdfFunctions-.pdf
Functions-.pdf
 
CH.4FUNCTIONS IN C (1).pptx
CH.4FUNCTIONS IN C (1).pptxCH.4FUNCTIONS IN C (1).pptx
CH.4FUNCTIONS IN C (1).pptx
 

Mehr von Mukund Trivedi

Mehr von Mukund Trivedi (20)

System development life cycle (sdlc)
System development life cycle (sdlc)System development life cycle (sdlc)
System development life cycle (sdlc)
 
Process of design
Process of designProcess of design
Process of design
 
New file and form 2
New file and form 2New file and form 2
New file and form 2
 
File organisation
File organisationFile organisation
File organisation
 
Evaluation
EvaluationEvaluation
Evaluation
 
Database
DatabaseDatabase
Database
 
Case tools
Case toolsCase tools
Case tools
 
Evaluation
EvaluationEvaluation
Evaluation
 
Dfd final
Dfd finalDfd final
Dfd final
 
Sad
SadSad
Sad
 
C++ file
C++ fileC++ file
C++ file
 
Ff40fnatural resources (1)
Ff40fnatural resources (1)Ff40fnatural resources (1)
Ff40fnatural resources (1)
 
Ff40fnatural resources
Ff40fnatural resourcesFf40fnatural resources
Ff40fnatural resources
 
F58fbnatural resources 2 (1)
F58fbnatural resources 2 (1)F58fbnatural resources 2 (1)
F58fbnatural resources 2 (1)
 
F58fbnatural resources 2
F58fbnatural resources 2F58fbnatural resources 2
F58fbnatural resources 2
 
F6dc1 session6 c++
F6dc1 session6 c++F6dc1 session6 c++
F6dc1 session6 c++
 
Ee2fbunit 7
Ee2fbunit 7Ee2fbunit 7
Ee2fbunit 7
 
E212d9a797dbms chapter3 b.sc2 (2)
E212d9a797dbms chapter3 b.sc2 (2)E212d9a797dbms chapter3 b.sc2 (2)
E212d9a797dbms chapter3 b.sc2 (2)
 
E212d9a797dbms chapter3 b.sc2 (1)
E212d9a797dbms chapter3 b.sc2 (1)E212d9a797dbms chapter3 b.sc2 (1)
E212d9a797dbms chapter3 b.sc2 (1)
 
E212d9a797dbms chapter3 b.sc2
E212d9a797dbms chapter3 b.sc2E212d9a797dbms chapter3 b.sc2
E212d9a797dbms chapter3 b.sc2
 

Kürzlich hochgeladen

UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8DianaGray10
 
Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Adtran
 
Videogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfVideogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfinfogdgmi
 
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostKubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostMatt Ray
 
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...DianaGray10
 
UiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation DevelopersUiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation DevelopersUiPathCommunity
 
9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding Team9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding TeamAdam Moalla
 
UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7DianaGray10
 
Designing A Time bound resource download URL
Designing A Time bound resource download URLDesigning A Time bound resource download URL
Designing A Time bound resource download URLRuncy Oommen
 
Cybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptxCybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptxGDSC PJATK
 
Empowering Africa's Next Generation: The AI Leadership Blueprint
Empowering Africa's Next Generation: The AI Leadership BlueprintEmpowering Africa's Next Generation: The AI Leadership Blueprint
Empowering Africa's Next Generation: The AI Leadership BlueprintMahmoud Rabie
 
COMPUTER 10: Lesson 7 - File Storage and Online Collaboration
COMPUTER 10: Lesson 7 - File Storage and Online CollaborationCOMPUTER 10: Lesson 7 - File Storage and Online Collaboration
COMPUTER 10: Lesson 7 - File Storage and Online Collaborationbruanjhuli
 
Machine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfMachine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfAijun Zhang
 
COMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a WebsiteCOMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a Websitedgelyza
 
Do we need a new standard for visualizing the invisible?
Do we need a new standard for visualizing the invisible?Do we need a new standard for visualizing the invisible?
Do we need a new standard for visualizing the invisible?SANGHEE SHIN
 
Cloud Revolution: Exploring the New Wave of Serverless Spatial Data
Cloud Revolution: Exploring the New Wave of Serverless Spatial DataCloud Revolution: Exploring the New Wave of Serverless Spatial Data
Cloud Revolution: Exploring the New Wave of Serverless Spatial DataSafe Software
 
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1DianaGray10
 
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...Will Schroeder
 
Comparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and IstioComparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and IstioChristian Posta
 
Bird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystemBird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystemAsko Soukka
 

Kürzlich hochgeladen (20)

UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8UiPath Studio Web workshop series - Day 8
UiPath Studio Web workshop series - Day 8
 
Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™Meet the new FSP 3000 M-Flex800™
Meet the new FSP 3000 M-Flex800™
 
Videogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfVideogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdf
 
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostKubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
 
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
Connector Corner: Extending LLM automation use cases with UiPath GenAI connec...
 
UiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation DevelopersUiPath Community: AI for UiPath Automation Developers
UiPath Community: AI for UiPath Automation Developers
 
9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding Team9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding Team
 
UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7
 
Designing A Time bound resource download URL
Designing A Time bound resource download URLDesigning A Time bound resource download URL
Designing A Time bound resource download URL
 
Cybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptxCybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptx
 
Empowering Africa's Next Generation: The AI Leadership Blueprint
Empowering Africa's Next Generation: The AI Leadership BlueprintEmpowering Africa's Next Generation: The AI Leadership Blueprint
Empowering Africa's Next Generation: The AI Leadership Blueprint
 
COMPUTER 10: Lesson 7 - File Storage and Online Collaboration
COMPUTER 10: Lesson 7 - File Storage and Online CollaborationCOMPUTER 10: Lesson 7 - File Storage and Online Collaboration
COMPUTER 10: Lesson 7 - File Storage and Online Collaboration
 
Machine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdfMachine Learning Model Validation (Aijun Zhang 2024).pdf
Machine Learning Model Validation (Aijun Zhang 2024).pdf
 
COMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a WebsiteCOMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a Website
 
Do we need a new standard for visualizing the invisible?
Do we need a new standard for visualizing the invisible?Do we need a new standard for visualizing the invisible?
Do we need a new standard for visualizing the invisible?
 
Cloud Revolution: Exploring the New Wave of Serverless Spatial Data
Cloud Revolution: Exploring the New Wave of Serverless Spatial DataCloud Revolution: Exploring the New Wave of Serverless Spatial Data
Cloud Revolution: Exploring the New Wave of Serverless Spatial Data
 
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
 
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
Apres-Cyber - The Data Dilemma: Bridging Offensive Operations and Machine Lea...
 
Comparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and IstioComparing Sidecar-less Service Mesh from Cilium and Istio
Comparing Sidecar-less Service Mesh from Cilium and Istio
 
Bird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystemBird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystem
 

85ec7 session2 c++

  • 1. Session – 2 Module-2 Prepared by - Neetu Gupta
  • 2. Contents • Control Statements – break, continue, switch, goto • Functions - arguments - return type • Scope – global & local scope • Scope operator • Storage classes – auto, register, extern, static
  • 3. Contents • Inline functions • Default arguments • Enumerations • Runtime stack • Command line arguments • Recursion
  • 4. 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;
  • 5. 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; }
  • 6. • 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.
  • 7. 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;
  • 8. continue statement - Example // continue loop example #include <iostream> using namespace std; int main () { for (int n=10; n>0; n--) { if (n==5) continue; cout << n << ", "; } return 0; }
  • 9. 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.
  • 10. 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;
  • 11. goto statement // goto loop example #include <iostream> using namespace std; int main () { int n=10; loop: cout << n << ", "; n--; if (n>0) goto loop; // loop is label here return 0; }
  • 12. 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
  • 13. 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 }
  • 14. 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).
  • 15. switch statement - Example // goto loop example #include <iostream> using namespace std; 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"; }
  • 16. 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
  • 17. 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.
  • 18. 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.
  • 19. 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.
  • 20. 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.
  • 21. 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
  • 22. 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.
  • 23. 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.
  • 24. • The following code depicts that how the addition function can be called in main() // function call - example #include <iostream> using namespace std; 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.
  • 25. 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.
  • 26. User Defined Function These are of Four type • No Arguments No return • No Arguments but Return • Arguments but No return • Arguments with Return
  • 27. 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(); }
  • 28. 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; cout<<“Enter Number”; cin>>n; for(i=n;i>0;i--) fact=fact*i; return fact; }
  • 29. 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; cout<<“Enter Number”; 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; }
  • 30. 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; cout<<“Enter Number”; 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; }
  • 31. 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
  • 32. 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.
  • 33. 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 ….. …. }
  • 34. 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.
  • 35. 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 //... } }
  • 36. • A complete program could be something like as below :
  • 37. 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.
  • 38. 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.
  • 39. 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
  • 40. 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.
  • 41. 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
  • 42. 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;
  • 43. // auto variable – Example #include <iostream> using namespace std; 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
  • 44. 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;
  • 45. // register variable – Example #include <iostream> using namespace std; 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.
  • 46. 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. • Scope is local to the block. • Life is, value of the variable persists between different function calls. • Variable is defined using keyword static static int I;
  • 47. // STATIC variable – Example #include <iostream> using namespace std; 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.
  • 48. 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. • Scope is local to the block. • 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)..
  • 49. • // 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.
  • 50. 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.
  • 51. 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.
  • 52. • 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 );
  • 53. // 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; }
  • 54. 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 !!)
  • 55. 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
  • 56. // factorial calculator - Example #include <iostream> using namespace std; 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.
  • 57. • 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.
  • 58. 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.
  • 59. // default values in functions #include <iostream> using namespace std; // 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
  • 60. • 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).
  • 61. 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
  • 62. 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.
  • 63. 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>>
  • 64. // 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. */
  • 65. 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.
  • 66. 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.
  • 67. • 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
  • 68. 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.
  • 69. 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.
  • 70. 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.
  • 71. 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.
  • 72. • 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.
  • 73. • 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.
  • 74. • 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
  • 75. • 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.