pass_by_reference.txt

Section 12: Pass by Reference
------------------------------------------------------------------------------------

Pass by Value

	- there are a few different ways you can pass data to a function

		+ pass by value

		+ pass by reference (C simulates)

	- pass by value is when a function copies the actual value of an
	  argument into the formal parameter of the function

		+ changes made to the parameter inside the function have
		  no effect on the argument

	- C programming uses call by value to pass arguments

		+ means the code within a function cannot alter the 
		  arguments used to call the function

		+ there are no changes in the values, though they had
		  been changed inside the function


Example: Pass by Value

/* function defintion to swap the values */

void swap(int x, int y) {

	int temp;

	temp = x; 	// save the value of x
	x = y;		// put y into x
	y = temp;	// put temp into y
}

int main(void) {

	// local variable definition
	int a = 100;
	int b = 200;

	printf("Before swap, value of a: %d\n", a);
	printf("Before swap, value of b: %d\n", b);

	// calling a function to swap the values
	swap(a, b);

	printf("After swap, value of a: %d\n", a);
	printf("After swap, value of b: %d\n", b);

	return 0;
}

Passing Data Using Copies of Pointers

	- pointers and functions get along quite well together

		+ you can pass a pointer as an argument to a function
		  and you can also have a function return a pointer
		  as its result

	- pass by reference copies the address of an argument into the
	  formal parameter

		+ the address is used to access the actual argument
		  used in the call

		+ means the changes made to the parameter affect the
		  passed argument

	- to pass a value by reference, argument pointers are passed
	  to the functions just like any other value

		+ you need to declare the function parameters as
		  pointer types

		+ changes inside the function are reflected outside the
		  function as well

		+ unlike call by value where the changes do not reflect
		  outside the function


Example Using Pointers to Pass Data

/* function definition to swap the values */
void swap(int *x, int *y) {

	int temp;
	
	temp = *x;	// save value at address x
	*x = *y;	// put y into x
	*y = temp;	// put temp into y
}

int main(void) {

	// local variables
	int a = 100;
	int b = 200;

	printf("Before swap, value of a: %d\n", a);
	printf("Before swap, value of b: %d\n", b);

	swap(&a, &b);

	printf("After swap, value of a: %d\n", a);
	printf("After swap, value of b: %d\n", b);

	return 0;
}


Summary of Syntax

	- you can communicate two kinds of information about a variable
	  to a function

		function1(x);

	- you transmit the value of x and the function must be declared
	  with the same type as x

		int function1(int num);

		function2(&x);

	- you transmit the address of x and require the function 
	  definition to include a pointer to the correct type

		int function2(int *ptr);


const Pointer Parameters

	- you can qualify a function parameter using the const keyword

		+ indicates that the function will treat the argument
		  that is passed for this parameter as a constant

		+ only useful when the parameter is a pointer

	- you apply the const keyword to a parameter that is a pointer
	  to specify that a function will not change the value to 
	  which the argument points

	  bool send_message(const char *pmessage) {

		// code to send the message
		return true;
	  }

	- the type of the parameter, pmessage, is a pointer to a
	  const char

		+ it is the char value that's const, not its address

		+ you could specify the pointer itself as const too,
		  but this makes little sense because the address is
		  passed by value

			- you cannot change the original pointer in 
			  the calling function

	- the compiler knows that an argument that is a pointer to
	  constant data will be safe

	- if you pass a pointer to constant data s the argument for a
	  parameter then the parameter must be used as above


Returning Pointers from a Function

	- returning a pointer from a function is a particularly 
	  powerful capability

		+ it provides a way for you to return not just a
		  single value, but a whole set of values

	- you would have to declare a function returning a pointer

	  int *name_of_function() {

		.
		.
		.
	  }

	- be careful though, there are specific hazards related
	  to returning a pointer

		+ use local variables to avoid interfering with
		  the variable that the argument points to