Why does my function only update the struct when I pass it with an & symbol?

Question

I'm studying coding for some credits in the university, and I was studying and decided to try to make something with structs in C++ to try to understand them better.

I'm trying to make some functions to work with the struct, but they only work if I write & before declaring the arguments, but in the classroom we were told it should not be necessary. My code is the following.

struct employee{
   int ID;
   char name;
   double salary;
};

struct empresa{
   char name;
   struct employee employee[];
};


void iterate_trough_employees(struct empresa &empresa, int number_employees){
    for ( int i = 0; i < number_employees; i++){
       empresa.employee[i].ID = i+1;
       printf("\n\n EL ID del empleado es:\t %d \n",empresa.employee[i].ID);
       empresa.employee[i].salary = rand() % 50;
       printf("El salario del empleado es: %.1lf \n", empresa.employee[i].salary);
       }
}

void sort_this(struct empresa &empresa, int number_employees){
   int list_of_ID[number_employees];
   list_of_ID[0]= empresa.employee[4].ID;
   printf("\n%d", empresa.employee[4].ID);
   printf("\n%d", list_of_ID[0]);
   printf("\n%.0lf\n", empresa.employee[6].salary);
}

int main(){
   struct empresa empresa;

   int empleados = 10;
   int orden_salarios[10];
   iterate_trough_employees(empresa, empleados);
   printf("%d", empresa.employee[6].ID);
   sort_this(empresa, empleados);

   return 0;
}

I'm mostly interested in the sort_this function, which only shows the correct values on screen when I write the K (the code in the function is not related to the title, because I have been trying to figure out the mistake making an easier function).

For those asking, we've been taught to code in C using some C++ elements (such as the pass by reference from C++ or cin/cout) to make it easier, and therefore it may seem to you that the code is not C nor C++. I'm studying coding for some credits in the university, and I was studying and decided to try to make something with structs in C++ to try to understand them better.

I'm trying to make some functions to work with the struct, but they only work if I write & before declaring the arguments, but in the classroom we were told it should not be necessary. My code is the following.

struct employee{
   int ID;
   char name;
   double salary;
};

struct empresa{
   char name;
   struct employee employee[];
};


void iterate_trough_employees(struct empresa &empresa, int number_employees){
    for ( int i = 0; i < number_employees; i++){
       empresa.employee[i].ID = i+1;
       printf("\n\n EL ID del empleado es:\t %d \n",empresa.employee[i].ID);
       empresa.employee[i].salary = rand() % 50;
       printf("El salario del empleado es: %.1lf \n", empresa.employee[i].salary);
       }
}

void sort_this(struct empresa &empresa, int number_employees){
   int list_of_ID[number_employees];
   list_of_ID[0]= empresa.employee[4].ID;
   printf("\n%d", empresa.employee[4].ID);
   printf("\n%d", list_of_ID[0]);
   printf("\n%.0lf\n", empresa.employee[6].salary);
}

int main(){
   struct empresa empresa;

   int empleados = 10;
   int orden_salarios[10];
   iterate_trough_employees(empresa, empleados);
   printf("%d", empresa.employee[6].ID);
   sort_this(empresa, empleados);

   return 0;
}

I'm mostly interested in the sort_this function, which only shows the correct values on screen when I write the K (the code in the function is not related to the title, because I have been trying to figure out the mistake making an easier function).

For those asking, we've been taught to code in C using some C++ elements (such as the pass by reference from C++ or cin/cout) to make it easier, and therefore it may seem to you that the code is not C nor C++.

Answer 1

When you declare a function with void foo(struct bar x) and you call it with foo(y), the compiler makes a copy of y and assigns that copy to x. Then changing the copy x inside the function has no effect on the original y.

When you declare a function with void foo(struct bar *x) and you call it with foo(&y), the compiler takes the address of y and assigns that value to x. Then x is a copy of the address, but you use *x or x->member inside the function, and these refer to the object at the address. Since the address points to the original object y, changing *x and x->member change the original object y.

When you declare a function with void foo(struct bar &x) and you call it with foo(y), the compiler takes the address of y and passes that to the function. When compiling the function, the compiler knows x is supposed to be a reference, not a pointer to or a copy of the original object. So, wherever x is used in the function, the compiler uses the address it was passed to refer to the original object. So changes to x in the function are changes to the original object. Where you write x.member = something;, the compiler uses the address that was passed for x to change the value of member in the original object y. This feature is only in C++; it is not in C.

The first is called pass by value.

The third is called pass by reference.

The second is equivalent to pass by reference except that it is manual instead of automatic; you explicitly pass a pointer and must manually write out the *x or x->member instead of x or x.member.

---

A note about struct empresa empresa; in main. Your struct empresa is defined with struct employee employee[];. This is a flexible array member, and defining an object of that type in this way does not allocate any storage for elements of the array. The proper way to use it is allocate storage for the base structure (sizeof(struct empresa)) plus as many elements as you want (+ empleados * sizeof(struct employee)). To do this, you will have to use malloc or a related function.

Flexible array members are an extension supported by some C++ implementations. They are not a standard part of the language.