Übersetzungs"schwierigkeiten" ( c/c++ -> delphi )

[HeikoDD]

Hallo, nah ist mir aber jetzt peinlich zu fragen.

Weiß zu fällig jemand ob mein Ansatz recht so ist:

original:

for (k = 0; k < x; ++k) {
tu doch was;
}

meine bisherige Lösung:

k := 0;
while (k < x) do begin
inc(k);
tu doch was;
end;

Was mich daran verwirrt ist der der dritte Teil in dem Kopf der C-Schleife. Der Counter soll vor dem Durchlauf hochgezählt werden?

Danke schon mal im voraus.

Heiko

[leddl]

Also sollte das wirklich der Fall sein, dass ein ++k im Schleifenkopf tatsächlich das k auch vor dem Durchlauf inkrementiert, dann kannst du das doch ganz einfach darstellen, indem du k gleich bei 1 starten lässt :zwinker:

Delphi-Quellcode:

for k := 1 To x-1 Do
Begin
  //Hier passiert was
End

bzw.

k := 1;
while k < x Do
Begin
  //wuppdi
  inc(k);
End;

[chaosben]

Zitat:

Zitat von HeikoDD

Der Counter soll vor dem Durchlauf hochgezählt werden?

Imho ja ... und deswegen muss deine Schleife bei 1 anfangen zu zählen.

//edit: recht hat der Axel :)

//edit2: scheinbar ist das alles Quatsch ... sieh unten

[OregonGhost]

Der Counter wird nicht vor dem Durchlauf hochgezählt. Die Anweisung ++k wird am Ende des Schleifendurchlaufs durchgeführt.

Code:

for (k = 0; k < x; ++k) {

}

wird genau wie

Code:

for (k = 0; k < x; k++) {

}

zu

Delphi-Quellcode:

for i := 0 to x - 1 do begin

end

.

k wird in beiden Fällen nach jedem Schleifendurchlauf inkrementiert. Der Unterschied liegt lediglich im Wert der Ausdrücke k++ bzw. ++k, der erste hat den Wert von k vor der Inkrementierung, der zweite hat den Wert von k nach der Inkrementierung.

[leddl]

Zitat:

Zitat von OregonGhost

Der Counter wird nicht vor dem Durchlauf hochgezählt. Die Anweisung ++k wird am Ende des Schleifendurchlaufs durchgeführt.

Das war mein erster Gedanke, aber da ich nichts zum Testen da habe, bin ich einfach mal davon ausgegangen, dass HeikoDD das schon getestet hat ;) Wenn du jetzt aber mit Sicherheit sagen kannst, dass das so nicht stimmt, dann fühle ich mich insgeheim bestätigt und ziehe meine Antwort von vorhin zurück :mrgreen:

//Edit:
Wobei ich meine Antwort ja sogar ausdrücklich nur für den Fall gegeben habe, dass ++k vor dem Schleifendurchlauf inkrementiert. Insofern brauche ich die ja nich mal zurückziehen :stupid:

[OregonGhost]

Ich kann es mit Sicherheit sagen, denn da ihr drei mich verunsichert habt, hab ich einfach mal testweise beide Schleifen kompiliert und bin zu identischen Ergebnissen gekommen, wie erwartet :mrgreen:

[Muetze1]

Ich hatte das selbe Thema auch schonmal hier angesprochen. Ich kenne es von anderen C Systemen aus früheren Zeiten noch, dort konnte man per Schreibweise (also ++k bzw. k++) festlegen, ob vor oder nach dem Durchlauf inkrementiert werden sollte. Dies wurde dann später mit dem festlegen im C99 (?) Standard (immer nach dem Durchlauf) eindeutig. Ich kenne wie gesagt auch einen Unterschied zwischen den Schreibweisen...

[Robert Marquardt]

Muetze1, das klingt aber sehr nach Unsinn.
Die for-Schleife ist von Beginn an als while-Schleife definiert worden.

Code:

for (expression1; expression2; expression3)
  DoSomething;

und

Code:

expression1;
while (expression2)
 {
  DoSomething;
  expression3;
 }

sind vollstaendig gleich!

Der Unterschied von k++ und ++k liegt im Wert des Ausdrucks. Beide male wird die Variable inkrementiert, aber k++ liefert den Wert vor der Inkrementierung und ++k nach der Inkrementierung.

[OregonGhost]

Der Unterschied liegt in C in der Tat nur im Wert des Ausdrucks. In C++ liegt er auch im auszuführenden Code. Wenn eine Klasse den Postfix-Operator überladen hat, muss der Compiler ihn ausführen, selbst wenn er für fundamentale Typen intelligent genug wäre, ihn in einen Präfix-Aufruf umzuwandeln. Das führt typischerweise auch zu einer Kopie des Objekts und somit zu Performance-Einbrüchen und im schlimmsten Fall zu Seiteneffekten (ist ja nicht vorgeschrieben, was man in so einem Operator überhaupt macht). Das braucht jemanden, der eine For-Schleife von C/C++ nach Delphi konvertieren will, im Normalfall aber nicht zu kümmern, bzw. nur, wenn der C++-Programmierer ein Sadist und/oder Masochist ist.

[Robert Marquardt]

Das ist der Grund warum ich das Ueberladen von Operatoren hasse. Man kann nicht mehr ohne einen moeglicherweise riesigen Kontext erkennen was in einer Source passiert. Schlimmstenfalls hat man den Kontext (die Implementierung der Ueberladung) nicht einmal vorliegen. Das wird jetzt allerdings OT.