Magic Numbers In Arrays? - C++

Question

I'm a fairly new programmer, and I apologize if this information is easily available out there, I just haven't been able to find it yet.

Here's my question:

Is is considered magic numbers when you use a literal number to access a specific element of an array?

For example:

arrayOfNumbers[6] // Is six a magic number in this case?

I ask this question because one of my professors is adamant that all literal numbers in a program are magic numbers. It would be nice for me just to access an element of an array using a real number, instead of using a named constant for each element.

Thanks!

Answer 1

That really depends on the context. If you have code like this:

arr[0] = "Long";
arr[1] = "sentence";
arr[2] = "as";
arr[3] = "array.";

...then 0..3 are not considered magic numbers. However, if you have:

int doStuff() 
{
   return my_global_array[6];
}

...then 6 is definitively a magic number.

Answer 2

It's pretty magic.

I mean, why are you accessing the 6th element? What's are the semantics that should be applied to that number? As it stands all we know is "the 6th (zero-based) number". If we knew the declaration of arrayOfNumbers we would further know its type (e.g. an int or a double).

But if you said:

arrayOfNumbers[kDistanceToSaturn]; 

...now it has much more meaning to someone reading the code.

In general one iterates over an array, performing some operation on each element, because one doesn't know how long the array is and you can't just access it in a hardcoded manner.

However, sometimes array elements have specific meanings, for example, in graphics programming. Sometimes an array is always the same size because the data demands it (e.g. certain transform matrices). In these cases it may or may not be okay to access the specific element by number: domain experts will know what you're doing, but generalists probably won't. Giving the magic index number a name makes it more obvious to those who have to maintain your code, and helps you to prevent typing the wrong one accidentally.

In my example above I assumed your array holds distances from the sun to a planet. The sun would be the zeroth element, thus arrayOfNumbers[kDistanceToSun] = 0. Then as you increment, each element contains the distance to the next farthest planet: mercury, venus, etc. This is much more readable than just typing the number of the planet you want. In this case the array is of a fixed size because there are a fixed number of planets (well, except the whole Pluto debacle).

The other problem is that "arrayOfNumbers" tells us nothing about the contents of the array. We already know its an array of numbers because we saw the declaration somewhere where you said int arrayOfNumers[12345]; or however you declared it. Instead, something like:

int distanceToPlanetsFromSol[kNumberOfPlanets];

...gives us a much better idea of what the data actually is and what its semantics are. One of your goals as a programmer should be to write code that is self-documenting in this manner.

And then we can argue elsewhere if kNumberOfPlanets should be 8 or 9. :)