Parameters

• Pass by value
  A copy of the value of the actual argument is placed in the memory location for the formal parameter
  Default
• Value arguments are like local variables, but function gets them automatically
• Common Mistake:Declaring parameters again inside function
  
• Pass by Reference
• Provide access to the caller's variables from within the function
• Actually modifies the caller's variables
• Space allocated for the formal parameter is just a pointer (short-cut) to the actual argument
• Use & after the type of the formal parameter
      void example (int &identifier)
• A modified validate function
  
  //This function validates user input to be less than range
  // repeatedly requesting input until correct
  void validate (int range, int &input) //validate function header
  {
      cin >> input;
      while (input < range)
      {
         cout << "Value must be at least " << range;
         cout << "\nEnter a correct value => " ;
         cin >> input;
      }
      return;
  }
  
• Validate Program Code   Output
• Grade Program Code   Output
• Grade Program Code   Output
• Constant Reference Paramenters
• Mixed Parameter Lists
  Notice that the Validate program used pass-by-value and pass-by-reference. When the value is only needed by the function (not modified), use pass by value.
  When a variable in the calling function (e.g. main) needs to be modified, use call-by-reference (or a return statement).
  When more than one variable in the calling function needs to be modified, one or more call-by-reference parameters are required.
• Remember: parameters are passed in the order listed, so the types of the actual arguments must correspond to the formal parameters
• See Power point example
• Inadvertent Local Variables
  If you forget the &, then pass-by-value is used, and a local variable is created
• Choosing Formal Parameter Names
  Use a meaningful name within the function
  It does not need to be the same name as the calling function

• scope - part of program where variable can be accessed
• local - within a function
• global - outside of all functions
• parameters are local variables - local to the function

  void t1();
  void t2();
  
  int main()
  {
     . . .
  }
  
  int globalvar;
  
  void t1(int localToFunction1)
  {
    . . .
  }
  void t2()
  {
     int localToFunction2;
     . . .
  }
  

• memory that was allocated for local vars deallocated at end of function
• memory for static local variables NOT deallocated

  void t1();
  
  int main()
  {
     t1();
     t1();
     return 0;
  }
  
  void t1()
  {
     static int x = 1;
     int y = 1;
    
     x++;
     y++;
     cout << "x is " << x << endl;
     cout << "y is " << y << endl;
  }
  

• memory that was allocated for local vars deallocated at end of function

• inline functions are not compiled, code is copied in
• use keyword inline when defining the function
  inline void f()
• called the same
  
• default arguments - give a value to the argument
• No value needed in call statement

  void printArea(double radius = 1)
  {
     double area;
     area = radius * radius * 3.14159;
     cout << "area is" << area << endl;
  }
  int main()
  {
     printArea(); // default value of 1 used
     printArea(4);
  
     return 0;
  }