Using prefix/postfix increment operator for simple incremental array access rather than actual index numbers

Question

I cannot decide which method is better with consideration of both readability and fault-tolerance.

Method #1:

Object[] objects = getArrayOfKnownLength();
int i = -1;
someMethod(objects[++i], objects[++i], objects[++i], objects[++i]);

Method #2:

Object[] objects = getArrayOfKnownLength();
someMethod(objects[0], objects[1], objects[2], objects[3]);

I have always done the second method, but there have been several cases where I got IndexOutOfBoundsException because I made some changes which affected the expected array element position. So I have been considering using the first method to prevent this issue. My only concern is that it may be less readable.

I know this is a very minor thing to be questioning, but I am curious what the majority opinion is.

Answer 1

As far as I can see, when you write:

I made some changes which affected the expected array element position

The advantage that you're focusing on is that in Method #1, the start position is only found in one place (the initial value of i) whereas in Method #2, that information is implicitly contained in all four array indexes.

Seen this way, the second method is a violation of the Don't Repeat Yourself (DRY) principle, as you're repeating knowledge. What you described is exactly the expected outcome when you violate DRY: when the repeated knowledge changes, you have a tricky, error-prone process of updating it in all the places it's contained.

---

However, I think we can do better than the first method too. Instead of the needlessly tricky increment operator, why not say directly what we mean:

Object[] objects = getArrayOfKnownLength();
int start = 0;
someMethod(objects[start], objects[start+1], objects[start+2], objects[start+3]);

Now we have all the benefits of the first method, without the ugliness and difficulty to read.

Answer 2

Your first method has 4 side effects (the pre-increments) while the second has none.

In general you should avoid side-effects if you can.

Furthermore, the second one is more clear about your intent. If I would see the first one in someone else's code I would ask myself if there was any reason for performing the pre-increments.

So, stick with the second option.

Answer 3

The First method is horrible on my vision and it does not prevent "Exception". The same feelings I have when I see "magic numbers"! XD

If possible, you need to change the architecture, something is wrong! Or You need to check it before to use it in the method! Or be right that those params always come with their values filled and in the same order!

Did You change the position of parameters? Refactoring or change the design...!