- The purposes of
parameters in functions are:
- Pass some item of information
from the caller function
to the called (callee) function
(input parameter)
- Pass some item of information
from the called (calle) function
back to the caller function
(output parameter)
- Pass some item of information from the caller function to the called (callee) function and back (input/output parameter)
- Pass some item of information
from the caller function
to the called (callee) function
(input parameter)
- I want to make sure you understand
what is going on when
a function is called with some parameters
- Example function call (with parameters):
void f(int a, int b) { // don't care what happens inside the function... }
int main(int argc, char *argv[]) { int x, y; x = 10; y = 100; f( x, y ); ... }
- From the scoping rules,
we conclude that:
- The variables x and
y are in the scope
of main()
- The variables a and
b are in the scope
of f()
Graphically:
So:
- main() cannot access
variables a and
b
- Nor can f() access variables x and y
- The variables x and
y are in the scope
of main()
- When a function is invoked (called) with parameters, then:
- Some information
of the actual parameter variable
is
copied into
the
(formal) parameter variables
Graphical depiction:
- Some information
of the actual parameter variable
is
copied into
the
(formal) parameter variables
- Very important:
- What information is being copied
depends on the
parameter passing mechanism
- The parameter passing mechanism defines how (= what information) the actual parameter variable is copied into the (formal) parameter variables
- What information is being copied
depends on the
parameter passing mechanism
- There are presently
two commonly used
paramter passing mechanisms:
- Pass-by-value
- Pass-by-refrence
(There are others, e.g., pass-by-name)
- Pass-by-value:
In the pass-by-value method, the value of the actual parameter is copied into the (formal) parameter variable - Pass-by-reference:
In the pass-by-value method, the address (reference) of the actual parameter is copied into the (formal) parameter variable
- Parameters in
C++ are
passed by value
by default
(i.e., omitting the special "&"
symbol)
Example:
void f ( int a, int b ) { .... } - When a parameter is
passed-by-value, the
value of the
variable
is
copied
into the (formal) parameter variable
of the function
- Example:
void f(int a, int b) { cout << "Before increment a = " << a << ", b = " << b << "\n"; a = a + 10000; // Update the parameter variables b = b + 10000; cout << "After increment a = " << a << ", b = " << b << "\n"; } int main(int argc, char *argv[]) { int x, y; x = 10; y = 100; cout << "Before f(x,y), x = " << x << ", y = " << y << "\n"; // prints: x = 10, y = 100 (not surprising) f(x, y); // Pass-by-value: copy x to a, y to b cout << "After f(x,y), x = " << x << ", y = " << y << "\n"; // prints: x = 10, y = 100 (unchanged) !!! }
- Example Program:
(Demo above code)
- Prog file: click here
-
Reason why the actual parameter variables are
not changed:
The following figure shows what is going on inside the computer when parameters are passed "by value":
Step by step:
- When main()
invokes:
f(x, y);the call-by-value mechanism will:
- Copy the value of
x (which is 10)
into
the parameter variable a
- Copy the value of
y (which is 100)
into
the parameter variable b
(See left half of the figure above)
- Copy the value of
x (which is 10)
into
the parameter variable a
- The function f() is then run...
In call-by-value, the function will use the values that were copied into the parameter variable
- Therefore:
-
Updating the parameter variable
will not affect the
actual parameter variables !!!
(See right half of the figure above)
-
Updating the parameter variable
will not affect the
actual parameter variables !!!
- When main()
invokes:
- Parameters in
C++ are
passed by reference
by
speficying & before the
name of the parameter
Example:
void f ( int & a, int & b ) { .... } - When a parameter is
passed-by-value, the
address (!!!) of the
variable
is
copied
into the (formal) parameter variable
of the function
- Example:
void f(int & a, int & b) <------ Only change !!! { cout << "Before increment a = " << a << ", b = " << b << "\n"; a = a + 10000; // Update the parameter variables b = b + 10000; cout << "After increment a = " << a << ", b = " << b << "\n"; } int main(int argc, char *argv[]) { int x, y; x = 10; y = 100; cout << "Before f(x,y), x = " << x << ", y = " << y << "\n"; // prints: x = 10, y = 100 (not surprising) f(x, y); // Pass-by-value: copy x to a, y to b cout << "After f(x,y), x = " << x << ", y = " << y << "\n"; // prints: x = 10010, y = 10100 (changed) <----- !!! }
- Example Program:
(Demo above code)
- Prog file: click here
-
Reason why the actual parameter variables are
updated:
The following figure shows what is going on inside the computer when parameters are passed "by reference":
Step by step:
- When main()
invokes:
f(x, y); // Pass variables by reference -> copy address !!!the call-by-reference mechanism will:
- Copy the address of
x (which is 7000)
into
the parameter variable a
(so a is now a
pointer variable !)
- Copy the address of
y (which is 7600)
into
the parameter variable b
(so b is also a
pointer variable !)
(See left half of the figure above)
- Copy the address of
x (which is 7000)
into
the parameter variable a
(so a is now a
pointer variable !)
- The function f() is then run...
In call-by-reference, the function will use the values that found through the address stored in the parameter variable
- Therefore:
-
Updating the parameter variable
will update the
actual parameter variables !!!
(See right half of the figure above)
-
Updating the parameter variable
will update the
actual parameter variables !!!
- When main()
invokes:
- The pass-by-reference
mechanism is often used to
return output values
Example:
void compute( double & sum, double & diff, double & prod, double & quot, double a, double b) { sum = a + b; diff = a - b; prod = a * b; quot = a / b; }
- Example Program:
(Demo above code)
- Prog file: click here
- There is one exception to
the rule in C++ where
variables are passed-by-value
by default
- For efficiency reasons
(copying a big array takes time),
arrays in C++
are passed-by-reference
by default
- Example:
void f( int a[] ) // No special & symbol... { a[0] = 10000 + a[0]; // will update actual parameter a[1] = 10000 + a[1]; a[2] = 10000 + a[2]; a[3] = 10000 + a[3]; }
- Example Program:
(Demo above code)
- Prog file: click here