Thread: Pointer Terminology Question

Hi, I'm not 100% confident on the following terms. I've seen them
used alot and never knew exactly knew what they meant,
so I continued to think of things like "point to this",
"follow the pointer to that" etc. But now that I have a better
understanding of how pointers work I'd like to know what exactly
it means when these terms are used.
Passing by value.
Passing by reference.
Dereference.
Direct Reference.
Indirect Reference.


Here is some sample code, are my
comments correct? Any help would be great.

Code:

#include <stdio.h>
#include <stdlib.h>

void func1(int *pointer);
void func2(int array[]);
void func3(int number);

int
main(void)
{
	int my_array[1000];
	int variable = 10;
	int *x;

	x = malloc(sizeof(int));

	/* Is this considered dereferencing *x? */
	*x = 99; 

	free(x);

	/* Passing by reference? */
	func1(&variable);
	func2(my_array);  

	/* Passing by Value?     */
	func3(variable);  
	
	return (0);
}

void func1(int *pointer)
{
	int value = 5;

	/* Dereferencing *pointer? */
	*pointer = value; 
}

void func2(int array[])
{
	int subscript = 0;

	/* Dereferencing array? */
	array[subscript] = 15; 
}

void func3(int number)
{
	/* Is this a direct reference to number? */
	number = 10; 
}

Also am I correct in assuming that an indirect reference to a
variable is the same thing as dereferencing the pointer that
points to its address? Like...

Code:

int *x;
int y = 10;

x = &y;

/*Dereferencing *x and also an indirect reference to y? */
*x = 15;

Again any help would be great, the book I'm reading doesn't
use any of these terms, these are just terms
I've heard used on IRC and on the boards sometimes.

>Passing by value.
This is how C passes function arguments, the value of the argument is copied and placed in the variable supplied by the definition:

Code:

int a = 10;

f ( a ); /* The value, 10, is passed to f */
.
.
.
void f ( int var ) /* The value, 10, is given to var */
{
  ...
}

>Passing by reference.
Passing by reference is when you give the function not a copy of the value, but another name that is the same as the original object, a synonym if you will. So changing it changes the original. C does not have this feature, so I'll use C++:

Code:

int a = 10;

f ( a ); // A reference, a different name that effects a, is passed
.
.
.
void f ( int& var ) // var is a different variable, but it's the same as a
{
  ...
}

>Dereference.
Used for pointers, dereferencing is when you follow a pointer to the address at which it points and obtain the value at that location.

>Direct Reference.
C does not have this feature, so once again I'll use references from C++. Direct reference is when you have a variable of another name that can be taken as a synonym for the original, much like a typedef:

Code:

typedef int my_int; // my_int is now int, but int still exists

int& my_a = a; // my_a is now a, but a still exists

>Indirect Reference.
This is what C uses, pointers to an object are indirect references to that object. The manner in which C simulates passing by references is to pass the value of a pointer (the address of the original object) to a function, then that address is assigned to another pointer by value but when dereferenced, the original object can still be accessed.

-Prelude