Kitty Corp Meow Mix Forums

Think of * as like a reference to an offset in a hex editor.
Let's say you have

struct Data
{
   int whatever1;
   int whatever2;
}

Data* exampleVar;

Think of * as like an array (Data[]) but with no absolute end.
The size of the Data struct is 8 bytes (two 4-byte ints. Int is a struct of 4 bytes), so when you use "exampleVar++" then the offset will progress 8 bytes forward.

If you want to assign "exampleVar" to a variable that isn't a pointer, you need to say
Data exampleVar2 = *exampleVar;

because exampleVar is simply an offset, not an actual variable. Adding * changes it into a variable.

You can also read the current value and progress forward afterwards with *exampleVar++;

If you want to assign a value within exampleVar, you need to use "exampleVar->whatever1" because you're assigning directly into the memory with a pointer.

Now let's say you have
Data exampleVar3;

In order to set the variables inside exampleVar3, you can just use "exampleVar3.whatever1" because it's not being accessed through a pointer.

But what if you're using a loop?
int[] variables = new int[2];
for (int i = 0; i < 2; i++)
{
   if (i == 0)
      variables[i ] = exampleVar3.whatever1;
   else
      variables[i ] = exampleVar3.whatever2;
}

It works, but it's not as efficient as
int[] variables = new int[2];
for (int i = 0; i < 2; i++)
{
   variables[i ] = ((int*)&exampleVar3)[i ];
}

Which does the exact same thing. (I put a space in [i ] or else it made the text italic lol)

&exampleVar3 is the "offset" of exampleVar3 in the memory.
(int*) changes that offset into an "array" of 4-byte integer values.
[i ] is the indexer that accesses the integers in that array in memory (it progresses every 4 bytes, the size of int).

If you already have Data* exampleVar, then you can use the indexer without getting the address.
exampleVar[i ]