Question

I have a function and i’m accessing a struct’s members a lot of times in it.
What I was wondering about is what is the good practice to go about this?

For example:

struct s
{
    int x;
    int y;
}

and I have allocated memory for 10 objects of that struct using malloc.

So, whenever I need to use only one of the object in a function, I usually create (or is passed as argument) pointer and point it to the required object (My superior told me to avoid array indexing because it adds a calculation when accessing any member of the struct)

But is this the right way? I understand that dereferencing is not as expensive as creating a copy, but what if I’m dereferencing a number of times (like 20 to 30) in the function.

Would it be better if i created temporary variables for the struct variables (only the ones I need, I certainly don’t use all the members) and copy over the value and then set the actual struct’s value before returning?

Also, is this unnecessary micro optimization? Please note that this is for embedded devices.

Answer 1

First of all, indexing an array is not very expensive (only like one operation more expensive than a pointer dereference, or sometimes none, depending on the situation).

Secondly, most compilers will perform what is called RVO or return value optimisation when returning structs by value. This is where the caller allocates space for the return value of the function it calls, and secretly passes the address of that memory to the function for it to use, and the effect is that no copies are made. It does this automatically, so

struct mystruct blah = func();

Only constructs one object, passes it to func for it to use transparently to the programmer, and no copying need be done.

What I do not know is if you assign an array index the return value of the function, like this:

someArray[0] = func();

will the compiler pass the address of someArray[0] and do RVO that way, or will it just not do that optimisation? You’ll have to get a more experienced programmer to answer that. I would guess that the compiler is smart enough to do it though, but it’s just a guess.

And yes, I would call it micro optimisation. But we’re C programmers. And that’s how we roll.