zB. habe ich:

for(int j; ; ){int i; ...}

Stimmt es, dass "i" und "j" erst nach Beendigung der kompletten Schleife vernichtet werden, also nicht nach jedem Schleifendurchlauf?!
So hab ich das jedenfalls verstanden.

Was ist nun aber mit Variablen (eig. Referenzen, denn so war das Beispiel..)
innerhalb einer Schleife in einer Schleife, also innerhalb von Mehrfachschleifen??

zB:

for_aussen(){ for_innen(){ int i; ... } }

Wird hier das "i" nach jedem Schleifendurchlauf von for_aussen() zerstört und wieder erzeugt???
(Würde ich erstmal so annehmen..) Und verhalten sich Referenzen identisch dazu?

Gibt es einen allgemeinen Tipp, wie mit Variablen innerhalb von Schleifen umzugehen ist?? Also zB. alle Variablen schon außerhalb einrichten...?!

Das wärs auch schon.

MfG
Klon457

PS. ...Sorry für den unformattieren Code, besser gings hier nicht...

for(int j; ; ){int i; ...}

Stimmt es, dass "i" und "j" erst nach Beendigung der kompletten Schleife vernichtet werden, also nicht nach jedem Schleifendurchlauf?!

j ist für die ganze Schleife gültig. i ist nur im Körper der Schleife gültig (dh wird jeweils am Ende zerstört und beim nächsten Durchlauf neu angelegt.)

Was ist nun aber mit Variablen (eig. Referenzen, denn so war das Beispiel..)
innerhalb einer Schleife in einer Schleife, also innerhalb von Mehrfachschleifen??

Prinzipiell gibt es da nichts neues.

Also zB. alle Variablen schon außerhalb einrichten...?!

Warum? Jede nur da wo sie gebraucht wird, im Normalfall so lokal wie möglich.

Stimmt es, dass "i" und "j" erst nach Beendigung der kompletten Schleife vernichtet werden, also nicht nach jedem Schleifendurchlauf?!

Nein. i wird in jedem Schleifendurchlauf erzeugt und zerstört; j nur einmal pro Schleifenausführung.
Schließlich wird doch der Scope bei jedem Schleifendurchlauf neu betreten und verlassen.

Der Standard definiert es trefflich:

The for statement
for ( for-init-statement condition_opt ; expression_opt ) statement
is equivalent to

{
    for-init-statement
    while ( condition ) {
        statement
        expression ;
    }
}

except that names declared in the for-init-statement are in the same declarative-region as those declared in the condition, and except that a continue in statement (not enclosed in another iteration statement) will execute expression before re-evaluating condition.

Wobei hier statement auch ein compound-statement sein kann, also mehrere Statements eingeschlossen in { und } .

Wird hier das "i" nach jedem Schleifendurchlauf von for_aussen() zerstört und wieder erzeugt???

Nein, i wird (genau wie oben) in jedem Betreten des Schleifenrumps erzeugt und zerstört.

Und verhalten sich Referenzen identisch dazu?

Oben genanntes gilt genauso für Referenzen.

Also zB. alle Variablen schon außerhalb einrichten...?!

Nein, gerade das solltest du vermeiden! Alle Variablen so lokal wie möglich deklarieren.

PS. ...Sorry für den unformattieren Code, besser gings hier nicht..

Nächtes mal die C++-Tags verwenden, sonst war alles in Ordnung.

Edit: Interessant. Wenn ich das C++-Code-Tag in ein italic-Tag-Paar packe, dann kommt nur [code] dabei raus!

Ich dachte, dass für die Körper-Vars gleiches wie für die Kopf-Vars gelten würde (mal davon abgesehen, dass da eigentlich "{}" die Vars einschließen)...
Ist das denn nicht allgemein unpraktisch/ungeschickt, etwas nach jedem Schleifendurchlauf zu vernichten, wenn es im nächsten wieder erzeugt wird??
Also in Sachen Syntax und Objektorientierung kann ich das ja noch nachvolliehen, aber der Rechner hat dadurch doch mehr Arbeit, oder nicht?
..Wenn sonst nicht viel in der Schleife passiert, könnte das Erzeugen/Vernichten schon ins Gewicht fallen, denke ich mal..

Ich bekomme es, wie gesagt, leider nicht mehr auf die Reihe, aber in dem Code mit der Referenz, war es eben gerade das Problem, dass man die Referenz nicht außerhalb erstellen konnte (...glaube ich...).

Wenn ich möglichst schnellen Code haben möchte, und mal angenommen, Variablen für Nichts zu zerstören und zu erzeugen dauert tatsächlich länger, welche Alternativen dazu habe ich denn?? ...Und falls es welche gibt, welche ist dann wirklich die schnellste Möglichkeit...??

Das ändert sich, wenn die Variable irgendwie initialisiert werden muss. Falls die Initialisierung auch vorher gemacht werden könnte, dann ist dies tatsächlich ein Fall, in dem man die Variable aus der Schleife ziehen kann und sollte. Bei einfachen Initialisierungen, die für den Compiler sichtbar sind, kann der Compiler diesen Vorgang in der Regel auch optimieren und die Variableninitialisierung selber rausziehen.
Extrembeispiel für eine unnötige, teure Initialisierung, die nicht automatisch optimiert werden kann:

for (char a = 0; a < 255; ++a)
{
  ofstream out("foo.bar");
  out << a;
}

Das out zieht man besser raus. Aber:

for (char a = 0; a < 255; ++a)
{
  double d = sin(a);
  cout << d;
}

Absolut keine Kosten für das d.

Auch gut zu wissen, wie die for-Schleife intern aussieht.
(Vllt. noch dazu: Gibt es eigentlich noch mehr Funktionen der Form "funkxy(;;;)", also mit ";", und kann ich mir die auch selbst machen ??)

Die sieht nicht intern so aus, sondern ist nur äquivalent dazu. Selbst machen kannst du dir sowas indem du eine eigene Programmiersprache entwickelst (und dazu einen Compiler).

init;
start:
 if (!cond)
   goto end;
 stmt;
 expr;
 goto start;
end: