What does it mean to put '*' in front of a variable?

Why was the data corrupted and why not now?

If we use variables it looks better:

void func(int var)
{
  var = 10;
}

int main()
{
  int a = 0;
  func(a);
  std::cout << a;
}

It doesn't matter how many times you execute the above code, it will always print 0and the reason is very simple: varit is a copy of a, so the changes we make to varit will not be echoed in var. It's like cloning a sheep... shearing the clone will not automatically shear the original sheep.

Now let's see the same example but with pointers:

void func(int * var)
{
  int n = 10;
  var = &n;
}

int main()
{
  int a = 0;
  int* ptr = &a;
  func(ptr);
  std::cout << a;
}

The program prints again 0... But we are using pointers! ... already, but as in the previous case, varit is a copy of ptr. The only thing that both pointers share is that they point to the same memory address, but they are still independent variables.

And this is where the trick comes in . What it does var=10is modify the address pointed to byvar . After this change, it ptrwill point to one memory address and aa different one.

Now instead, imagine we change the example a bit:

void func(int * var)
{
  int n = 10;
  *var = n;
}

Now the program, by magic, will print a 10!!!

What happened now?

What happens now is that, thanks to the use of the asterisk, we are modifying the memory shared by both pointers, varand ptr.

That is why this change is propagated outside the function.

Having said this, I take this opportunity to clarify a small detail: In your first case, it is not that the data was corrupted... it is that you were not modifying the original memory , which remained unchanged as it was when the function was called.

Why was the data corrupted and why not now?

The data was corrupted because in your function_inityou were assigning the memory address of the variable newPoputo the pointer object, the content of that address was pointed to by both variables, but when exiting the function that content was removed just like newPopuand therefore objectnot pointed to the data you expected. When you do *object = newPoputhis by assigning the content of the variable and not the memory address it is in, then you have two references to that content, one is objectand one is newPopu, when you exit the function it newPopuceases to exist but objectstill points to an address of memory that contains the value that was assigned inside the functionfunction_init

What does that asterisk in front of an assignment mean in my code?

That asterisk indicates that you are going to access the content at the memory address that is pointed to by your variable, in this case object.

Let's imagine the following:

 typedef struct
 {
     int a;
     int b;
 }tPopularity;

void function_init(tPopularity* object) 
 {
    tPopularity newPopu = {1, 2};
    object = &newPopu;
}

Let's assume the memory addresses that our memory block will have (this block is basically where the aand members will be stored b) that the implicit pointer newPopu(del function_init) points to.

--> Bloque A:
(a)   (b)     
0x4 - 0x8     
//El puntero implícito newPopu apunta a la dirección 0x4.

Now, with this data, let's start by seeing how the following line works:

object = &newPopu;

We are clear that this statement is equivalent to this:

object = &newPopu.a;

What you are assigning to the pointer object(in this case 0x4) is the first memory address (in this case 0x4) of the block A that it points to newPopu, but then we realize that the pointer objectis a parameter and that later, when the function function_initfinishes its execution , the memory space where the pointer is located object, will be freed from the program and also block A. In short, your function caused it to lose all the information that block A has and that is the reason why the data corruption happens .

Now the solution to this problem is the one you proposed:

*object = newPopu;

Now I'll add a little code to reflect why:

int main(void)
{
    tPopularity ob;
    function_init(&ob);
    printf("%d %d\n", ob.a, ob.b);
    //Resultado por pantalla: 1 2
    return 0;
}

What this simple code does is copy all the data that the object (pointed newPoputo) has to the object pointed to ob(del main).

And to make this clearer, the code:

*object = newPopu;

It is equivalent to :

object-> a = newPopu.a;
object-> b = newPopu.b;

And with this we check WHY data corruption does not occur.

I hope my explanation helps you! Cheers!