What does putting & in front of a struct mean?

And when I wanted to use it, I didn't need it with pointers.

So you shouldn't use pointers:

bool film_equals(tFilm* film1, tFilm* film2);
//               ~~~~~^        ~~~~~^
//                  \              \___ Puntero a 'tFilm'
//                   \___ Puntero a 'tFilm'

If you want instances instead of pointers, omit the asterisk ( *):

bool film_equals(tFilm film1, tFilm film2);
//               ~~~~~        ~~~~~
//                  \            \___ Instancia de 'tFilm'
//                   \___ Instancia de 'tFilm'

why does it fail if i don't put & in front of the parameters?

The et operator gets a pointer to an instance. So if you have an object of type tFilmcalled film, when you apply the operator et: &filmyou get a pointer to tFilm( tFilm*) which is exactly what your function asks film_ecualsfor and so it fails if it doesn't provide arguments that match the signature of the function. function.

Let's imagine that our structure tFilmwas declared like this:

typedef struct 
{
    int price;
    int film;
}tFilm;

Then, we are going to suppose that the offsets of each member of the structure tFilmare the following:

typedef struct 
{
    int price; //offset 0
    int film;//offset 4
}tFilm;

The only thing that the offset indicates is the displacement necessary to be able to add it to the base address (that of the first member) of the structure and thus obtain the memory address of some member of the structure tFilm.

Ready, having this information, we can easily understand the following question:

What does putting & in front of a struct mean?

To answer the question, I will pose the following code:

bool film_equals(tFilm* f1, tFilm* f2)
{
    return (f1->film == f2->film);
}

int main(void)
{
    tFilm film1 = {2, 23}; //Se crea la primera estructura en memoria
    tFilm film2 = {3, 26};//Se crea la segunda estructura en memoria
    if(film_equals(&film1, &film2))
        printf("Equals!");
    else 
        printf("No-equals!");
    return 0;
}

In the example above, we define two implicit pointers ( film1and film2) and initialize the structure with default values.

Additionally, we will assume the memory addresses of the two structures we have created in memory:

-> 1. film1
int price; -> Address: 0x4
int film; -> Address: 0x8

-> 1. film2
int price; -> Address: 0x24
int film; -> Address: 0x28

When this function is called:

film_equals(&film1, &film2)

What would we be going through?

Basically what we are passing is the base address of the struct tFilm.

And this is because, because the code above actually converts to this:

film_equals(&film1.price, &film2.price)

So that later, the compiler interprets it in this way (this is the way it would be read at a low level):

film_equals(film1 + 0, film2 + 0)

If you notice, the member priceis actually replaced by its respective offsetone (obviously this is calculated by the compiler itself).

So, if we know that the implicit pointer film1has the base address (in this case it is 0x4) of the structure tFilm, just by adding a 0to said address, we would obtain the memory address of the first member and this also applies to the implicit pointer film2.

So, this means that the first parameter of the function film_equalswill have the address stored 0x4(which corresponds to the memory block pointed to by film1).

The same would happen with the second parameter, it would be passing the address 0x24(because it corresponds to the address of the first member pointed to film2).

Now understanding this, we can conclude that if we were to remove the ampersand &in the following call:

film_equals(film1, film2)

What we would be passing is the content of the first member of the structure tFilm. Basically the equivalent code would be like this:

film_equals(film1.price, film2.price)

Which in turn, the compiler interprets it this way:

//Acuérdate, el offset del miembro price dijimos que iba a ser 0.
film_equals(*(film1 + 0), *(film2 + 0))

So, we realize, what we are passing in this case, is the content that has both memory addresses ( 0x4corresponds to the first member of the block1 it pointed to film1and 0x24the block2 it pointed to film2).

And if we check our table that we had previously placed, it tells us what the first parameter of the function would receive, film_equalswhich would be a 2(this was the value that the member priceof the first memory block pointed to had film1) and the second parameter would receive a 3(this was the value held by the member priceof the second memory block pointed to by film2).

However, this is dangerous, because the addresses 0x2are 0x3received by the function pointers, but then the routine would access those addresses that we don't even know if they belong to the program or not, that is, the application would stop working, because the system operative will not allow you to access an address in which you do not have access.

FOR THAT REASON it is NECESSARY to prepend the ampersand &to the pointers film1, film2otherwise a segmentation fault will occur .

Now, let's continue with the next question:

Being tFilm film a parameter of the function and temporary->e.film a node whose value is the film

This could only happen if our function was defined like this:

bool film_equals(tFilm f1, tFilm f2)

When calling the function:

film_equals(film1, film2)

No execution error would occur in the program, what's more, everything would be safe.

Nevertheless, ...

Why didn't a segmentation fault occur?

The answer is simple. The base address that the implicit pointer has stored is not being passed film1, rather, memory would be reserving for a new type structure tFilm, that is, the content of the previous memory block is copied to the new memory block. So, we can conclude that both the first and second parameters, what it receives is the base address of the new memory block that has been reserved and this is known as passing by value and as you know, if we repeat this process many times, it will be slow and this is due to the creation of a new object (block or memory region) and above all, to the copy of data that must be sent to the new object to which the first or second parameter of the function will point film_equals.

Recommendation: Always use pass by reference in these cases, this way you send the memory address directly, however, you must be careful not to forget to put the ampersand ( &) before it.

I found your question very interesting. I hope my explanation helps you.

Being declared with asterisks bool film_equals(tFilm* film1, tFilm* film2);means that it receives apuntadores: memory addresses a tFilm*. With &it you get the memory address of filmand of temporal->e.film. If you remove the you &are not passing memory addresses ( apuntadores), but values ​​and that is the reason it thunders.