Is it fair to say that all parameters or arguments are copied when passed to functions in C?

Question

From Why does scanf() require &?, it is mentioned that

all arguments in C are passed by value.

void change( int * var ) {
    // Here, var is a pointer to the original number. var == &value
    // Writing to `*var` modifies the variable the pointer points to
    *var = 1337;
}

Could I write instead

void change( int * var ) {
    // Here, var is a copy of a pointer that happens to point to the same memory block as the original pointer. var == &value
    // Writing to `*var` modifies the variable the pointer points to
    *var = 1337;
}

Assuming

int main() {
    int value = 42;
    change(&value);
    return 0;
}

Nothing can be passed in C is a correct statement using the conventional meaning of "pass". Is my understanding sound?

---

My question rephrased is: Can anything truely be passed in C (the conventional use of "pass")?

Answer 1

Yes, everything* in C is passed by value, which means that copies of arguments are passed to function - that's the only way of passing values to functions. "Pass by pointer" (or "reference") doesn't really exist - it's still "passing by value", where "value" is pointer. Pointers are values after all.

---

Linguistic note: when we say "could you pass me some sugar please" we expect someone to temporarily transfer possession of sugar bowl to us, so at any moment of time there's only one sugar bowl. In other words, we expect sugar bowl to be moved to us. That's not the case in programming. "Passing" in this context means merely "associating parameters with function being called", and doesn't necessarily involve moving. That's why we differentiate between "pass-by-value", "pass-by-reference", "pass-by-name" etc.

---

Example:

/* I have 2 apples, 3 oranges and one pear */
int apple = 2;
int orange = 3;
int pear = 1;

/* Apples are my favorite fruit */
int *my_favorite_fruit = &apple;

void no_eat_fruit (int fruit) {
    /* Does not work, "fruit" is copy, so changes to it have no effect outside function */
    fruit--;
}
no_eat_fruit(apple);
/* No apples have been eaten at this point */


void eat_fruit(int *fruit) {
    /* Here, "fruit" is copy, but "*fruit" refers to original object */
    *fruit--;
}
eat_fruit(&apple);
eat_fruit(my_favorite_fruit);
/* I have no apples left */

/* Let's change my mind, now I like oranges */

void no_change_my_mind(int *favorite) {
    /* Doesn't work, "favorite" is copy, so changes to it have no effect outside function */
    favorite = &orange;
}
no_change_my_mind(my_favorite_fruit);
/* I still like apples, LOL! */

void change_my_mind(int **favorite) {
    /* In order to change pointer, we have pass pointer-to-pointer.
       Here, "favorite" is copy, but "*favorite" points to original pointer */
    *favorite = &orange;
}
change_my_mind(&my_favorite_fruit);

---

* with exception to arrays. Arrays "decay into pointers" when passed into function.

Answer 2

This question has been racking my brains. I had to prove it. Out of respect for el.pescado's efforts, I am leaving his or her answer as accepted answer.

Code

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


void copy( int * memoryslot )
{
  /* This does not prove that * memoryslot is a copied pointer */
  printf("copy:              ValueCopied:        %p\n", memoryslot);  /* memoryslot is a ptr    */
  printf("copy: CalculatedPointerAddress:        %p <- Well, it is not. Here is the proof.\n", &memoryslot); /* get address of pointer */
  * memoryslot = 30; /* To prove I can still use a copy to change the original value */
  return;
}

int main(void) 
{
  int memoryslot = 20;
  int * memoryslotPtr = &memoryslot;
  printf("Caller                 Pointer to memory slot\n");
  printf("-------------------------------------\n");
  printf("main:                    Value:        %d\n", memoryslot);
  printf("main:   CalculatedValueAddress:        %p\n", &memoryslot);
  printf("main: CalculatedPointerAddress:        %p <- If * memoryslot were the same, it would be this.\n", &memoryslotPtr);

  /* Pass address, yields same as &memoryslot */
  copy( memoryslotPtr ); 

  printf("main:                    Value:        %d\n", memoryslot);


  return EXIT_SUCCESS;
}

Output

Caller                 Pointer to memory slot
-------------------------------------
main:                    Value:        20
main:   CalculatedValueAddress:        0x7ffee9134c48
main: CalculatedPointerAddress:        0x7ffee9134c40 <- If * memoryslot were the same, it would be this.
copy:              ValueCopied:        0x7ffee9134c48
copy: CalculatedPointerAddress:        0x7ffee9134c08 <- Well, it is not. Here is the proof.
main:                    Value:        30