Setting all possible combinations of values I have a circumstance where I need to create every single possible version of an object upon a particular magnitude. After this, a process occurs which determines the best combination of values at this magnitude and then sets these for the next iteration of the magnitude reduction loop.

const int magReductions = 2//As an example; would be user decided 
int currentItem;
double bestVal1 = 5,
       bestVal2 = 5,
       bestVal3 = 5,
       bestVal4 = 5,
       bestVal5 = 5;

for (double magnitude = 1; magnitude &gt; pow(10, -magReductions); magnitude /= 10) {    
    for (int a = 0; a &lt; 10; a++) {
        for (int b = 0; b &lt; 10; b++) {
            for (int c = 0; c &lt; 10; c++) {
                for (int d = 0; d &lt; 10; d++) {
                    for (int e = 0; e &lt; 10; e++) {
                        currentItem = (10000 * a) + (1000 * b) + (100 * c) + (10 * d) + e;
                        objectList[currentItem].val1 = ((a - 5) * magnitude) + bestVal1;
                        objectList[currentItem].val2 = ((b - 5) * magnitude) + bestVal2;
                        objectList[currentItem].val3 = ((c - 5) * magnitude) + bestVal3;
                        objectList[currentItem].val4 = ((d - 5) * magnitude) + bestVal4;
                        objectList[currentItem].val5 = ((e - 5) * magnitude) + bestVal5;
                    }
                }
            }
        }
    }
//function calculating best values
}


It is very hard to give a concise example of this in action due its nature of being very heavy on computing power.

Quite a while after writing this I look at it with quite a lot of suspicion that it is rather badly done, although no alternative method seems to present itself to me. I suppose I ask the very typical question of this site, 'Is there a better way?'.
Based on how you store objects at indices determined by the init values, and not stored in sequential order, I'm going to guess that you have a function somewhere that takes an object's index and returns the matching values of a,b,c,d,e.

Let's say it's std::tuple&lt;int,int,int,int.int&gt; get_values(int obj_index);

You could leverage that same function to clean up the generating loop:

for(int i=0; i &lt; 10*10*10*10*10; ++i) {
  auto values = get_values(i);
  objectList[i].val1 = ((std::get&lt;0&gt;(values) - 5) * magnitude) + bestVal1;
  objectList[i].val2 = ((std::get&lt;1&gt;(values) - 5) * magnitude) + bestVal2;
  objectList[i].val3 = ((std::get&lt;2&gt;(values) - 5) * magnitude) + bestVal3;
  objectList[i].val4 = ((std::get&lt;3&gt;(values) - 5) * magnitude) + bestVal4;
  objectList[i].val5 = ((std::get&lt;4&gt;(values) - 5) * magnitude) + bestVal5;
}


If you don't have such a function, then indexing the objects in the way you do makes no sense, and you should just be storing them in order of generation.

Apart from that, my other recommendations would be too dependant on the context. 

For instance, I would look for a way to not have to store the entire table of objects, and implement the evaluation algorithm in a way that at most a few objects have to be in existence at the same time.

I would also consider that brute-forcing an optimization problem like this is generally a last resort, so I would probably look for tackling this with something like a gradient descent if possible.