Dynamische Anzahl an for-schleifen?

Hallo zusammen

Vlt. hab ich gerade einfach nur ein Brett vor dem Kopf... folgende Problemstellung:

Ich habe einen Vektor, der Zeiger auf Objekte vom Typ Parameter speichert. Jeder Parameter hat einen min- und max-Wert sowie eine Schrittweite "stepwidth". Der Vektor kann beliebig viele dieser Parameter enthalten. Ich möchte jetzt gerne folgendes irgendwie dynamisch lösen:

std::vector<Parameter*> vecParam;
        vecParam.push_back(a);
        vecParam.push_back(b);
        vecParam.push_back(c);

        for(int i=a->min; i<=a->max; i+=a->stepwidth) {
            for(int j=b->min; j<=b->max; j+=b->stepwidth) {
                for(int k=c->min; k<=c->max; k+=c->stepwidth) {
                    std::cout<<i<<"\t"<<j<<"\t"<<k<<std::endl;
                }
            }
        }

Es sind 3 Zeiger auf Parameter im Vektor und es werden alle Kombinationen durchprobiert. Jetzt kann der Vektor aber auch 5 oder 7 oder 19 Zeiger enthalten, die dann alle wie oben durchlaufen werden sollen.

Ist die Lösung so simpel, dass ich sie nicht erkenne Oder würdet ihr einen anderen Ansatz wählen?

SeppJ

Das würde ich mit einer Rekursion lösen. Geht jetzt ein Licht auf oder sagt dir das nichts?

Rekursion ist mit definitiv ein Begriff, aber ich kann gerade den Bezug nicht herstellen noch keine

Momentan versuche ich, einer Funktion den Vektor und einen index mitzugeben, also

void Rek(std::vector<Parameter*> vecParam, int index) {

Das geht wohl soweit auch erstmal, allerdings hab ich dann ja z.B. auf unterster Rekursionsebene nicht alle Werte zur Verfügung. Ich muss ja weiterhin mit den Werten arbeiten

Michael E.

Dann solltest du nicht nur einen Index als Parameter mitgeben, sondern einen Container voll Indizes.

SeppJ

Oder eine andere (vermutlich bessere) Idee: Du machst dir so eine Art Klasse für große Zahlen. Nur die einzelnen Ziffern haben nicht immer den selben Wertebereich sondern eben den der am Anfang in deinen Parametern steckt. Und dann zählst du einfach immer um eins hoch. Wenn eine Ziffer dabei ihren Wertebereich überschreitet, so fangt sie wieder von vorn an und schickt ihrerseits ein Signal an die nächste Ziffer, sich um eins zu erhöhen.

Das müsste eigentlich ziemlich gut gehen und wäre vermutlich effektiver als die Rekursion (wobei Effizienz bei Konsolenausgabe vernachlässigbar ist, aber vielleicht willst du ja mal was anderes damit machen).

Jetzt bezogen auf deine aktuelle ausgabe:
Gib ihm einfach einen std::vector<int> mit, in dem die aktuelle funktion ihren aktuellen wert pusht und dann übergibt ....

typedef std::vector<int> intvec;
....
void Rek(std::vector<Parameter*> vecParam, int index, intvec veci);

der index ist dann das aktuelle element deines parameter-vectors.
Ich kann mir vorstellen, dass mein vorschlag etwas unschön ist, aber es sollte funktionieren.

wenn du dann statt der ausgabe nach dem rekursiven durchlauf mit den ergebnissen weiterarbeiten möchtest, müsstest du noch einen vector<intvec> machen und referenz mit übergeben...

... naja nur n vorschlag
und wenn ich schwachsinn verzapfe: sagen ^^

krümelkacker

Hier mal ein Tipp

#include <iostream>
#include <ostream>
#include <vector>
using namespace std;

bool increment(vector<int> & v)
{
  int pos = v.size();
  while (pos>0 && v[pos-1]++==2) v[--pos]=0;
  return pos>0; // OK? (kein Ueberlauf)
}

int main()
{
  const int ziffern = 3;
  vector<int> aktuell (ziffern);
  do {
    for (int k=0; k<ziffern; ++k) cout<<aktuell[k];
    cout << endl;
  } while (increment(aktuell));
}