Wie viele Parameter weiterleiten

Hi, man kann meiner main Funktion viele parameter übergeben, die meisten werden dann an Subfunktionen weitergeleitet oder wieder unterfunktionen dieser und so weiter. Funktionen leiten diese teils nur weiter und verwenden sie nicht selbst.
Die unterfuntkionen haben auch weider andere parameter, die von den Elternfunktionen erst generiert wurden.

Mit allen zusammen haben dann manche Unterunterfunktionen über 10 Parameter.

Kann man das irgendwie besser machen? Globale variablen sollte man ja auch nicht machen.

Wenn einige der Parameter häufig gleich sind, kann man sie in einer Struktur zusammenfassen:

struct Params
{
  int p1;
  std::string p2;
};

vielleicht besser zerlegen?

Func1(a,b,c,d,e,f,g,h)
{
Func2(a,b,c,d,e)
i = xyz
j = abc
Func3(f,g,h, i,j)
}

(sinnvoll) Umbauen in

Func2_Object(a,b,c,d,e)
Func3_Object(f,g,h)
Func1(Func2_Object, Func3_Object)
{
Func2_Object.doit();
i = xyz
j = abc
Func3_Object.doit(i, j)
}

die Anteile die fest bleiben in eine Klasse schieben
die Varianten Anteile als Methoden-Parameter dazu

Falls du deinen Code hier einstellen kannst oder ein sinnvolles Beispiel hast das auch komplex genug ist wäre es wohl einfacher zu erklären

Im Normallfall lassen sich schon saubere Grenzen ziehen

erstmal danke für die antworten. Ein struct übergeben kannte ich zwar schon habe es aber noch einmal überdacht. An einer stelle würde es gehen, das struct müsste ich aber als template machen. Aber das geht ja auch.

Gast3 schrieb:

vielleicht besser zerlegen?

Func1(a,b,c,d,e,f,g,h)
{
Func2(a,b,c,d,e)
i = xyz
j = abc
Func3(f,g,h, i,j)
}

Das geht meist nicht, da Func3 auch z.B. a braucht, ebenso das Ergebenis von func2. Sind also nicht immer in fester Reihenfolge sondern überschneiden sich teils.

Gast3 schrieb:

(sinnvoll) Umbauen in

Func2_Object(a,b,c,d,e)
Func3_Object(f,g,h)
Func1(Func2_Object, Func3_Object)
{
Func2_Object.doit();
i = xyz
j = abc
Func3_Object.doit(i, j)
}

die Anteile die fest bleiben in eine Klasse schieben
die Varianten Anteile als Methoden-Parameter dazu

Derzeit wird in Func3 ein Objekt erstellt, etwas berechnet und dieses weiter verwertet. Das Objekt ist ein Template, eines Types der in Func1 das erste mal vorkommt. Damit müsste ich entweder den Templatetyp schon vor Func1 kennen oder ich hätte mit Func3_Object ein Objekt welches ein Objekt abhängig vom template erstellen kann. Macht das Sinn?
Oder angenommen man editiert Func3 und findet ein anderes Objekt, welches die Aufgabe besser erfüllt. Dann müsste man dann ja auch die Elterfunktion derElterfunktion verändern (das Func3_Object).

Nochmal überlegen, alles reinstellen werde ich nicht können (groß). Mal sehen, ob mir ein vereinfachtetes Beispiel einfällt.

Printe

DingsvomDach schrieb:

Mit allen zusammen haben dann manche Unterunterfunktionen über 10 Parameter.

Man könnte sagen: Funktionen, die so viele Parameter brauchen, machen zuviel. Wenn du Funktionen in Unterfunktionen zerlegst (um mal in deiner Sprechweise zu bleiben), dann mach das nach Möglichkeit so, dass jede Unterfunktion eine unabhängige Teilaufgabe erfüllt und daher auch nur einen Teil des Parametersatzes benötigt, der in die Oberfunktion reingeht.

Man kann solche Parameter-structs auch selbst wieder aggregieren, das mache ich oft so. Und man kann das mischen:
wichtige und nicht-optionale Parameter werden normal übergeben. Parameter, für die sinnvolle Defaults existieren, kommen in die struct.
Mit dieser Vorgehensweise lässt es sich recht angenehm arbeiten.

struct AParams
{
  int a=0;
  int b=0;
  int c=0;
  int d=10;
  int e=20;
};

struct BParams
{
  int f=0;
  int g=0;
  int h=0;
};

struct CParams
{
  AParams aParams;
  BParams bParams;
};

FuncC(CParams p={})
{
  FuncA(p.aParams)
  i = xyz
  j = abc
  FuncB(i,j,p.bParams)
}