All parameters to functions are values. Therefore if you want to pass
a "reference" to an object, you must pass the value of its address as
an argument. This is also hte only way to alter the "value" of an
object inside a function - you pass its address and modify whats at
that address.

For example

void foo(int x)

x is an int value. If you change x inside the function, the change is
lost, since x is a local copy of value of the variable.

void foo(int *x)

x is an int pointer value. if you change x you lose the change as
before. However now you can change what x points to, and this change
is remembered.

Mark McIntyre

C- FAQ: http://www.*-*-*.com/ ~scs/C-faq/top.html

I read all funtion arguments in C are passed "by value", not "by reference",
and
cannot understand it exactly. I want some more explanation with examples.

Have a Great Day!!!

Call by value means that the formal parameter -- that is, the variable
actually inside the function -- has the *value* of the actual parameter
*copied* into it.  This means that changes to the formal parameter don't
result in changes to the actual parameter.

  int foo (void)
  {
    int actual = 1;
    bar(actual);
    printf ("%d\n, actual);   /* Prints 1 */
  }

  int bar (int formal)
  {
    formal = 2;
    printf ("%d\n, formal);   /* Prints 2 */
  }

Call by reference means that the formal parameter becomes a "reference" to
the actual parameter, i.e. just another way of referring to exactly the same
thing.  This means that changes to the actual parameter are reflected in the
formal parameter.

If we imagine that C used call by reference, then

  int foo (void)
  {
    int actual = 1;
    bar(actual);
    printf ("%d\n, actual);   /* Would print 2... */
  }

  int bar (int formal)        /* ...because 'formal' is just another */
                              /* name for 'actual'...                */
  {
    formal = 2;               /* ...and we set it to 2 here */
    printf ("%d\n, formal);
  }

"Call by value" and "call by reference" are also called "pass by value" and
"pass by reference"; it's the same thing.

There is a third method, "pass by name", which is broadly similar to what
happens with macro substitution in C.  You're unlikely to encounter it in
any other context.

A nice thought, though statistical analysis suggests it is unlikely.

Cheers
Richard
--
The FAQ is at http://www.eskimo.com/~scs/C-faq/top.html
New users try http://www.sin.khk.be/~emulov/c.l.c/welcome_to_clc.htm

http://www.eskimo.com/~scs/C-faq/s4.html

Bill, faqqer.