// bildbeispiel einlesen
for(int zeile=1; zeile<=8;++zeile)
  {
  for(int spalte=1; spalte<=8;++spalte)
    {
    puffer_graustufe=bilder[bildnummer][zeile][spalte];
    neuronkernfeuerrate[zielnetz][1][(((zeile-1)*8)+spalte)]=puffer_graustufe;
    SchichtenObjekt(1, (((zeile-1)*8)+spalte), 0, 0, puffer_graustufe, RGB(puffer_graustufe,puffer_graustufe,puffer_graustufe), true, true);
    }
  }

mit dummyvariablen (für true,true) gings glaub mal,
aber geht das nicht eleganter ?

(wenn du nicht vorhast, über die Parameter etwas zurückzugeben, definier sie als Wert oder const-Referenz)

void SchichtenObjekt(int schicht, int index, int &koordiante_left, int &koordiante_top, int &caption, int &color, bool schreiben_caption, bool schreiben_color);

je nach den boolischen werten schreibe oder lese ich

hmm unser c++ lehrer hat uns beigebracht daß es die linksseitige ausgabe und unedlich ein/ausgaben gibt.

deklaration

void SchichtenObjekt(int schicht, int index, int &koordiante_left, int &koordiante_top, int &caption, int &color, bool schreiben_caption, bool schreiben_color);

je nach den boolischen werten schreibe oder lese ich

Das klingt für mich nach einem Design-Fehler. Ich würde die Aufgaben lieber verteilen auf eine Lese- und eine Schreib-Methode.
(und in deinem obigen Code hast du zumindest für color tatsächlich vor, in eine temporäre Variable zu schreiben)

hmm unser c++ lehrer hat uns beigebracht daß es die linksseitige ausgabe und unedlich ein/ausgaben gibt.

Was soll uns dieser Satz jetzt sagen? Und was hat er mit dem Problem zu tun?

hier hab ich das immer so behandelt als könnte man den parameter als ein oder ausgabe verwenden.

das hier geht:

bool TrainingEvoNetQuali(int netz, int ausgangszuordnung, int *&biggest_value, int *&secound_biggest_value); // gibt true zurück wenn der größte wert der ausgangszuordnung(synonym zielindex) entspricht. zu bewertendes netz, ausgangszuordnung, array mit pointern auf die 2 größten werte ([1]=größter [2]=zweitgrößter)

da hole ich einen zeiger aus der funktion raus.
hmm die reihenfolge von * und & hätt ich aber andersrum gewählt.
hat & hier eine andere bedeutung ?

das in extra funktionen aufzuteilen würde viel redundanten code bedeuten.
nunja ih wollt es eh ml dynamisch lösen aber dazu müßt ich einiges zur laufzeit erzeugen.

es ist eigendich nur eine konverterfunktion
das ist drin:

void TForm1::SchichtenObjekt(int schicht, int index, int &koordiante_left, int &koordiante_top, int &caption, int &color, bool schreiben_caption, bool schreiben_color)
{
// wenn caption/color 0 sind werden sie it dem wert aus dem pannel gefüllt
// ansonsten wird ihr inhalt in das panel geschrieben.

// panel caption darf nicht "" sein sonst exception

switch (schicht)
  {
  case 1:
  switch (index)
    {
    case 1:
    koordiante_left = Panel1->Left + (Panel1->Width/2);
    koordiante_top = Panel1->Top + (Panel1->Height/2);
    if(!schreiben_caption)
      caption = StrToInt(Panel1->Caption);
    else
      Panel1->Caption = caption;
    if(!schreiben_color)
      color = Panel1->Color;
    else
      Panel1->Color = (TColor)color;
    break;

    case 2:
    koordiante_left = Panel2->Left + (Panel2->Width/2);
    koordiante_top = Panel2->Top + (Panel2->Height/2);
    if(!schreiben_caption)
      caption = StrToInt(Panel2->Caption);
    else
      Panel2->Caption = caption;
    if(!schreiben_color)
      color = Panel2->Color;
    else
      Panel2->Color = (TColor)color;
    break;

und fröhlich weiter

Das & kennzeichnet in beiden Fällen eine Referenz auf den links daneben stehenden Typen. Das wäre im ersten Fall int und im zweiten int*.
Wenn ein Parameter für Ein-/Ausgaben verwendet werden kann, dann kannst du ihm doch dann beim Aufruf keine Konstante zuweisen (wie oben geschehen).

egal wenn ich mich hier zum schlumpf mache:
bei zeigerdefinitionen heißt das & doch daß die adresse der variable zurückgegeben wird.

Ja - aber du verwendest dort oben keine Zeiger, sondern Referenzen (eine Abart von Zeigern, die automatisch dereferenziert wird). Und eine Referenz muß auf eine gültige Variable verweisen (bei konstanten Referenzen sind dafür temporäre Variablen erlaubt).

heißt das, daß der stern da überflüssig ist ?

Nicht unbedingt - die Funktion TrainingEvoNetQuali() nimmt Referenzen auf int-Zeiger entgegen, das hat durchaus seine Berechtigung.

PS: Deine Funktion sieht ja grauenhaft aus - viel zu viele Aufgaben auf einen Haufen. Das solltest du auseinandernehmen in einzelne Funktionen für jede Aufgabe (Koordinaten holen, Caption lesen, Caption schreiben,...).

beispielaufruf:

puffer_netqualirueckgabe = TrainingEvoNetQuali(1,puffer_ausgangszuordnung,biggest_rates[1][1],biggest_rates[1][2]);

wenn ich da immer variablen nehmen sollte würde das zu haufen dummyvariablen wie int dummy_1=1; führen oder wie soll man das sonst machen ?

jo kann ich mal auseinanderfuseln.

das lehrzeichen setze ich dan also bei der deklaratin dieser refferenz:
int &biggest_value
sinnigerweise besser so:
int &biggest_value
?

also mit & nur für leses und ohne nur für schreiben verwenden ?

Ja.

das lehrzeichen setze ich dan also bei der deklaratin dieser refferenz:
int &biggest_value
sinnigerweise besser so:
int &biggest_value
?

Wie du das setzt, ist dem Compiler egal - hauptsache du weißt, was es bedeutet (ich setze es meistens so: int*& biggest_value (oder lasse es ganz weg)).