Directly Addressing Array Memory

Question

I presently trying to learn how to write in memory in various ways, i.e. I'm playing.

I've created a struct as follows:

struct strProjectile
{
    int Damage;
    int ParticlesPerSecond;
    short Fire;
    short Plasma;
};

I've then created an array as follows:

strProjectile Projectiles[40];

From that array, I've then created a pointer to point at the beginning of the array:

strProjectile *ptrProjectiles;
ptrProjectiles = Projectiles;

Using that pointer, you can set the values in the variables like so (I know this can be done directly not using the pointer too using the . notation):

ptrProjectiles->Damage = 0;
ptrProjectiles->ParticlesPerSecond = 0;
ptrProjectiles->Fire = 0;
ptrProjectiles->Plasma = 0;

I have also found I can set the values in the variables by creating a pointer to each of the variables in each struct of the array. For example, the following would set Damage to 0:

int *Damage = (int *)ptrProjectiles;
*Damage = 0;

My question is can I use the pointer to the array directly to set each variable within the struct directly in memory as I did using the separate pointer for damage above? Using something like:

*ptryProjectiles = 0;

then skipping 4 bytes of memory to get to the next variable in the struct (in this case, ParticlesPerSecond), set that, then skip 4 bytes more and set the next variable (in this case, Fire), then skip the next 2 bytes and set the next variable (in this case, Plasma), then skip 2 more bytes to get the next object in the array and then repeat....

I cant see a reason I need to do this, but just want to know if it can be done for my full understanding....

Thanks in advance!

Answer 1

In general, you address arrays of structures directly through the array as follows:

strProjectiles[2].Damage=0;

If you want an individual element:

Projectile * p= &strProjectiles[3];
p->Damage=0;
(*p).Fire=1;

Answer 2

With this statement, you're assuming int Damage; will always be the first field:

int *Damage = (int *)ptrProjectiles;

This is prone to future bugs and should not be used. If you want to set only the int Damage; field in each structure, you use use a loop:

strProjectile Projectiles[MAX_PROJECTILES];
strProjectile *ptrProjectiles = Projectiles;

for(i = 0; i < MAX_PROJECTILES; i++)
    (ptrProjectiles + i)->Damage = 0;

Update

It is possible, though dangerous, to calculate the address of each structure's first field like this:

int *pDamage = (int *)Projectiles;

for(i = 0; i < MAX_PROJECTILES; i++)
{
    *pDamage = 0;
    pDamage = (void *)pDamage + sizeof(Projectiles[0]);
}

Answer 3

TLDR: Yes, but you probably shouldn't.

You can totally do this in C. You could even take in a bytestream and typecast it to your struct and have all of the data members filled out immediately.

The nuance to this is that it is not maintainable code, so... probably not a good idea IRL. Another point to note is that once you've done this type of accessing/setting of variables, you're married to your data structure. You can't really change it, move variables around, add additional data members or anything really without reworking all of your code.

Answer 4

OK, thanks for the tips and advice but figured out what I was trying to do....

Firstly, to skip forward between each entry in the array I need to use:

ptrProjectiles = (strProjectile *)((char *)ptrProjectiles + sizeof(strProjectile));

which basically makes it skip 12 bytes at a time.

Assuming its packed correctly with consistent padding of the struct, then the following can be used to set the value of each variable directly in memory:

*(int *)ptrProjectiles = 0;
*(int *)((char *)ptrProjectiles + 4) = 0;
*(short *)((char *)ptrProjectiles + 8) = 0;
*(short *)((char *)ptrProjectiles + 10) = 0;

This does what I was looking for. Bringing it all together, I could then 0 each of the entries in the array with:

int lenProjectiles = sizeof(Projectiles);

for (int i = 0; i < lenProjectiles; i = i + sizeof(strProjectile))
{
    ptrProjectiles = (strProjectile *)((char *)ptrProjectiles + sizeof(strProjectile));
    *(int *)ptrProjectiles = 0;
    *(int *)((char *)ptrProjectiles + 4) = 0;
    *(short *)((char *)ptrProjectiles + 8) = 0;
    *(short *)((char *)ptrProjectiles + 10) = 0;
}

Answer 5

Pretty much everything you wrote is correct, however, there are some important details:

It is perfectly valid code to convert a struct pointer to a pointer to its first element, as in your line

int *Damage = (int *)ptrProjectiles;

This fact is used heavily in object oriented programming, where the first member of a struct (read class) is a variable that contains the base class subobject (another struct). That way a pointer to the subclass can directly be converted into a pointer to the base class and vice versa.

However, it is invalid to try to access the second element of the struct in such a way, i. e.

int* ParticlesPerSecond = (int*)ptrProjectiles + 1;    //Wrong!

is not guaranteed to yield the same result as

int* ParticlesPerSecond = &ptrProjectiles->ParticlesPerSecond;    //Correct.

The reason is alignment: The compiler is free to add padding between elements of a struct which is forbidden in an array.

For the other two members, the situation is even worse: They have a different type than the first member, so they may have different alignment requirements. That makes their offsets pretty unpredictable. Nevertheless, you can compute their offsets with this code:

size_t FireOffset = (size_t)&((struct strProjectile*)0)->Fire;
size_t PlasmaOffset = (size_t)&((struct strProjectile*)0)->Plasma;

This trick has frequently been used in the implementation of the offsetof() macro (offsetof in wikipedia), which is the more canonical way to get the offsets:

#include <stddef.h>

size_t FireOffset = offsetof(struct strProjectile, Fire);
size_t PlasmaOffset = offsetof(struct strProjectile, Plasma);

With this knowledge, you can produce the correct member pointers yourself:

short* Fire = (short*)((char*)ptrProjectiles + FireOffset);
short* Plasma = (short*)((char*)ptrProjectiles + PlasmaOffset);

I hope I don't have to mention that you shouldn't be doing this unless you have very good reason to do so. Studying purposes qualify for almost anything, though...