void iterPath(std::vector<int> &vM,const int &iValue,int *pResult){

	int iBlock= vM[vM.size()-1];
	int iGroup= 1;

	for(int k=vM.size()-1; k>=0; k--){

		int iCalc= iValue;

		iCalc= iCalc%iBlock==0 ? iBlock : iCalc%iBlock;
		pResult[k]= iCalc%iGroup==0 ? iCalc/iGroup : iCalc/iGroup+1;

		iGroup= iBlock;
		if(k>0)
			iBlock= iBlock* vM[k-1];

	}
}

Optimierung hinsichlich Performance (Schneller machen) ??

Bsp:

man hat 3 Elemenete A, B, C

Element A hat 3 Alternativen
Element B hat 2 Alternativen
Element C hat 4 Alternativen

Aus diese Konstellation 3*2*4 gibt es als 24 Möglichkeiten der auswahl von Kombinationen. siehe tabelle:

A B C
01 1 1 1
02 1 1 2
03 1 1 3
04 1 1 4
05 1 2 1
06 1 2 2
07 1 2 3
08 1 2 4
09 2 1 1
10 2 1 2
11 2 1 3
12 2 1 4
13 2 2 1
14 2 2 2
15 2 2 3
16 2 2 4
17 3 1 1
18 3 1 2
19 3 1 3
20 3 1 4
21 3 2 1
22 3 2 2
23 3 2 3
24 3 2 4

Die funktion macht nun ichts anderes wie die berechun der Kombination (A,B,C) durch wahl der nur 1- 24...

probiers mal so. ich hab mal das modulo weggetan. is natuerlich von compiler abhaengig, ob er das nicht sowieso schon gemacht hat.

void iterPath(std::vector<int> &vM,const int &iValue,int *pResult)
{
   int iBlock = vM[vM.size() - 1];
   int iGroup = 1;

   for(int k = vM.size() - 1; k >= 0; k--)
   {
      int iCalc = iValue;
      int temp = iCalc / iBlock; 
      iCalc = (temp * iBlock) == iCalc ?  iBlock : iCalc - (temp * iBlock);
      temp = iCalc / iGroup;
      presult[k] = (temp * iGroup) == iCalc ? temp : temp + 1;
      iGroup = iBlock;
      if(k > 0)
         iBlock *= vM[k - 1];
   }
}

Meep Meep

void iterPath(std::vector<int> const& vM, int iValue, int *pResult)
{ 
    sizt_t l = vM.size();
    for (size_t n = 0; n < l; n++)
    {
        pResult[n] = iValue % vM[n];
        iValue /= vM[n];
    }
}

Oder verstehe ich die Anforderungen jetzt falsch...
Und vergib mal gescheite Namen für deine Variablen, das ist ja furchtbar.
Und const correctness wäre fein, und integers übergibt man nicht als "const int&", das macht keinen Sinn und ist bloss langsam.