Programmierer-Ehren-Codex

[RMC]

Es gilt ja sozusagen als ungeschriebenes Gesetz in der Programmierer-Welt, sozusagen als "Etiquette" der Programmierer, KEINE GoTo Befehle zu verwenden...man will ja sportlich fair bleiben :)

In C, C++ gabs ja welche..unter DOS :) Weiß gar nicht mehr obs die überhaupt in Java oder ähnlich aktuelleren Programmiersprachen noch gibt?

Ich habs ohne GoTo gelernt, hab NIE eins eingesetzt und werd das auch sicher nicht machen. Saubere Programmierung ist das allerhöchste Gebot!
Und immerhin ist es ja grad die Herausforderung, besonders schwere Algorithmen kompakt und schön zusammenzuschrauben *g*

Sieht das noch irgendwer so? Oder setzt ihr permanent GoTos ein? Habt ihr das genauso oder ist euch das egal?

[Coda]

C/C++ hat noch goto, auch in den neusten Compilern.

Es gibt durchaus Situationen in denen ein goto sinnvoll ist. Bestes Beispiel ist der Linux Kernel, da findet man die reihenweiße.
Ein bischen steckt da schon ein Mythos dahinter, so evil sind gotos gar nicht.

Ich selber benütze sie aber nie, weil ich nie so performancekritischen Code habe, der es unbedingt erfordert.

[ethrandil]

Das geht auch fast unter Java, dazu mehr wenn ich wiederkomme (um 17:00)

- Eth

[pajofego]

Jo, ich muss die gotos, um verschachtelte for-Schleifen wieder verlassen zu können, verwenden. Sonst komm ich da nicht so schnell raus! =)

[RMC]

Original geschrieben von pajofego
Jo, ich muss die gotos, um verschachtelte for-Schleifen wieder verlassen zu können, verwenden. Sonst komm ich da nicht so schnell raus! =)

aso? es gibt sowas wie "Schalter" die du setzen kannst um bei gewissen Bedingungen die Schleife einfach verlassen zu können...außerdem gibts den Befehl "break" aber der ist umgefähr genauso sinnvoll wie ein goto *gg*

Faulheit?

[PH4Real]

Also ich finde, dass GOTO Befehle im Allgemeinen massiv die Lesbarkeit des Quellcodes beeinträchtigen... Ich mag es überhaupt nicht, wenn irgendwelche Funktionen oder Schleifen "per Hand" durchbrochen werden und deswegen benutze ich solche Methoden auch nicht.

Zwar können manche IDEs wie Eclipse 3.0 alle Stellen markieren, bei denen zum Beispiel eine Methode verlassen wird, aber es ist trotzdem nicht optimal.

[DocEW]

Eigentlich brauchst du ja nur ein Boolean "abbruch" oder sowas. Das kommt in jeder Schleife als zusätzliche Abbruchbedingung dazu. Wenn du es irgendwo setzt, fliegst du sofort überall raus.

[pajofego]

Original geschrieben von RMC
Faulheit?
...sag doch nicht sowas:)

Hab mal das hier für eine verschachtelte Suche in mehreren ArrayList Objekten gebraucht.

for (j=0 ; j<FCloseSet.CatalogNo; j++)
for (k=0; k<FCloseSet[j].NoOfStocks; k++)
if (FCloseSet[j].Stocks[k].WKN == WKN) goto Found;
Found: HPrice = FCloseSet[j].StockPrices;


Ich denke es ist noch recht lesbar, oder? Es war auch das einzige Mal, dass ich ein "goto" verwendet habe.

[RMC]

wie DocEW gesagt hat (und wie ich darüber gesagt habe *g*) du kannst einen Schalter setzen (ein boolean) dass, sobald die Bedingung im IF zutrifft, dieses boolean auf TRUE setzt (zB könnte es heißen "exit", "abbruch" o.Ä.).
In der for-Schleife machst in der Bedingung noch dazu

for(...&& !exit...)

fertig :)

und das spart dir das goto, ist schöner, sauberer, vertretbarer *gg*

Ja, ich mag gotos auch nicht :)

[pajofego]

Original geschrieben von RMC
wie DocEW gesagt hat (und wie ich darüber gesagt habe *g*) du kannst einen Schalter setzen (ein boolean) dass, sobald die Bedingung im IF zutrifft, dieses boolean auf TRUE setzt (zB könnte es heißen "exit", "abbruch" o.Ä.).
In der for-Schleife machst in der Bedingung noch dazu

for(...&& !exit...)

fertig :)

und das spart dir das goto, ist schöner, sauberer, vertretbarer *gg*

Ja, ich mag gotos auch nicht :)

Ach so, jetzt ich vertehen! Kannte ich nur noch nicht! Habs in der Doku von C# nicht gefunden. Dort wird die Lösung mit goto angepriesen!

[grakaman]

Original geschrieben von pajofego
Ach so, jetzt ich vertehen! Kannte ich nur noch nicht! Habs in der Doku von C# nicht gefunden. Dort wird die Lösung mit goto angepriesen!

Doch, das müsste gehen, indem du die verknüfte Bedingung im Expression Abschnitt schreibst. Bsp:

for(int i = 0; i < 10 && flag == false; i++)

edit: Allerdings ist das bei komplexen Sachen auch nicht gerade elegant, da du dann deinen Expression Abscnitt zumüllst. Ich halte break für angemessen.

[HellHorse]

unter Java kannst du folgendes machen:

outerloop : for(...) {
for(...) {
if (...)
break outerloop;
}
}

Unter Scheme, kannst du noch was viel cooleres machen: continuations
(define (outer-loop l condtion found not-found)
(if (null? l)
(not-found)
(inner-loop (car l)
condtion
found
(lambda ()
(outer-loop (cdr l) condtion found not-found)))))

(define (inner-loop l condition found not-found)
(if (null? l)
(not-found)
(if (condition (car l))
(found (car l))
(inner-loop (cdr l) condition found not-found))))

[Darkstar]

Original geschrieben von RMC
In C, C++ gabs ja welche..unter DOS :) Weiß gar nicht mehr obs die überhaupt in Java oder ähnlich aktuelleren Programmiersprachen noch gibt?GOTO, BREAK und EXIT gibt es natürlich auch in Object Pascal (Delphi).
Oder setzt ihr permanent GoTos ein?GOTOs habe ich bisher nur in BASIC benutzt! :D

Aber auf BREAK und EXIT (natürlich in Maßen eingesetzt – nicht in Massen) würde ich nur ungern verzichten, da der Schleifenkopf doch erheblich entlastet wird.
...außerdem gibts den Befehl "break" aber der ist umgefähr genauso sinnvoll wie ein goto *gg*Wenn ich mich nicht irre, ist es in C/C++/Java ziemlich schwer, ohne BREAK bzw. GOTO gescheite CASE-Anweisungen zu basteln. :P

[bulla]

Also bei Java gibts an sich keinen Goto-Befehl.
Eclipse hält diesen Befehl zwar geschützt, wurde aber nie angewendet.

Stattdessen gibts continue und break, jeweils mit Sprungmarken eingesetzt ist es recht flexibel und oft die einzige vernünftige Möglichkeit, aus inneren Schleifen rauszukommen.

[govou]

Original geschrieben von RMC
Es gilt ja sozusagen als ungeschriebenes Gesetz in der Programmierer-Welt, sozusagen als "Etiquette" der Programmierer, KEINE GoTo Befehle zu verwenden...man will ja sportlich fair bleiben :)

In C, C++ gabs ja welche..unter DOS :) Weiß gar nicht mehr obs die überhaupt in Java oder ähnlich aktuelleren Programmiersprachen noch gibt?

Ich habs ohne GoTo gelernt, hab NIE eins eingesetzt und werd das auch sicher nicht machen. Saubere Programmierung ist das allerhöchste Gebot!
Und immerhin ist es ja grad die Herausforderung, besonders schwere Algorithmen kompakt und schön zusammenzuschrauben *g*

Sieht das noch irgendwer so? Oder setzt ihr permanent GoTos ein? Habt ihr das genauso oder ist euch das egal?
Scheinbar sitzt du vor einem C++-Buch in dem steht, dass GoTo sehr böse ist. Was fürn Quatsch. Das hat nichts mit irgeneinem Kodex zu tun (gibs den?), sonst wäre goto schon längst aus allen möglichen Sprachen verbannt worden. Es gibt manchmal die Situation, wo goto wirklich sinnvoll ist. Darauf wirst du stoßen, wenn du mehrere jahre programmierst.
In QBasic bin ich früher z.B. ohne GoTo und GoSub ausgekommen, also ist es unsinn dies so zu verallgemeinern.
Nochmal um Kodex: Fast jeder Programmierer hat seinen eigenen Stil, z.B. im Geben von Variablennamen (manche setzten noch die Abkürzung für den benutzten Datentyp davor, also int i_zahl;).
Einen wiklichen Kodex gibt es also nicht, nur gibt es Sachen, an die man als Programmierer vielleicht denken sollte, um seinen Code nach einer längeren Pause noch verstehen zu können oder um diesen anderen verständlich zu machen. Dazu gehört halt das Benutzen vpn Whitespaces, klare Variablennamen, sinnvolle Kommentare etc.

[PH4Real]

Original geschrieben von Beh
Nochmal um Kodex: Fast jeder Programmierer hat seinen eigenen Stil, z.B. im Geben von Variablennamen (manche setzten noch die Abkürzung für den benutzten Datentyp davor, also int i_zahl;).

Und genau DAS ist ein großes Problem bei Team Projekten (und ein großes Problem für manchen Programmierer, dessen "Ego" schnell verletzt ist, wenn er in seinem "Style" nicht programmieren kann/darf). Für solche Fälle gibt es sehr wohl Code-Richtlinien, Kodex, Code-Conventions oder wie Du es immer auch nennen magst.

Und da sollte dann auch so ziemlich alles im kleinsten Detail geregelt sein (Benennung von Konstanten, Membervariable, Anzahl von Spaces nach Einrückungen, Methodenschreibweise etc.).

Man kriegt nämlich wirklich schnell den Knall, wenn die zum Beispiel eine Hälfte die Interfaces mit "I" vorneweg benennt und die andere Hälfte das nicht macht...

Original geschrieben von Beh
Es gibt manchmal die Situation, wo goto wirklich sinnvoll ist. Darauf wirst du stoßen, wenn du mehrere jahre programmierst.

Dazu braucht man aber nicht Jahre lang programmiert zu haben ;)...
Naja, also die wirklich einzige sinnvolle Anwendung ist das vorzeitige Verlassen von verschachtelten, inneren Schleifen und selbst dort gibt es Alternativen (s.o.). Alles andere finde ich ziemlich "dreckig"...

[Trap]

Heute über goto zu diskutieren ist unsinnig, die Diskussion ist 40 Jahre alt und es ist alles gesagt. Das Goto-considered-harmful paper sollte man sich vielleicht angucken.

Code-Konventionen sind IMO total unsinnig. Theoretisch kann man 99% der Konventionen vollautomatisch umsetzen. Warum sollte man das als Programmierer machen, der Computer kann das schneller und fehlerfreier.

[Matti]

Man sollte es mit goto nicht übertreiben, aber es gibt Situationen, wo ein Sprung eben einfacher und übersichtlicher ist:

for(x=...
{
for(y=...
{
...
if(...) goto label1
}
}
label1:CloseHandle(...
...

ohne goto müßte man eine zusätzliche Status-Variable einführen (langsam und unübersichtlich) oder die verschachtelte Schleife in eine extra Funktion packen (unübersichtlich und minimal langsamer).

[Einfachkrank]

Die oben dargestellte doppel For-Schleife ist ja ne gezählte Schleife, also könnte man auch das "goto LabelnachderSchleife" durch ein "SetzebeideZähleraufMaximum" ersetzen...

Meine Frage dazu: Was ist schneller?

[RMC]

Original geschrieben von Beh
Scheinbar sitzt du vor einem C++-Buch in dem steht, dass GoTo sehr böse ist. Was fürn Quatsch. Das hat nichts mit irgeneinem Kodex zu tun (gibs den?), sonst wäre goto schon längst aus allen möglichen Sprachen verbannt worden. Es gibt manchmal die Situation, wo goto wirklich sinnvoll ist. Darauf wirst du stoßen, wenn du mehrere jahre programmierst.
In QBasic bin ich früher z.B. ohne GoTo und GoSub ausgekommen, also ist es unsinn dies so zu verallgemeinern.
Nochmal um Kodex: Fast jeder Programmierer hat seinen eigenen Stil, z.B. im Geben von Variablennamen (manche setzten noch die Abkürzung für den benutzten Datentyp davor, also int i_zahl;).
Einen wiklichen Kodex gibt es also nicht, nur gibt es Sachen, an die man als Programmierer vielleicht denken sollte, um seinen Code nach einer längeren Pause noch verstehen zu können oder um diesen anderen verständlich zu machen. Dazu gehört halt das Benutzen vpn Whitespaces, klare Variablennamen, sinnvolle Kommentare etc.

Ich programmier seit 5 Jahren..

Gotos hab ich bis jetzt nur in PIC und IBM Assembler und ich glaub PL/1 verwendet, weil es da nicht anders ging. Bei Assembler setzt man eine Marke und springt dort wieder hin (somit hat man eine Schleife *gg*)

Aber in heutigen, objektorientierten Programmiersprachen ist das sinnlos geworden.
Gotos zu verwenden zeichnet eben einen genauso schlechten Stil aus wie schlechte Variablennamen, unübersichtliche Code-Anordnung, keine Inline-Dokumentation etc.

Das BREAK ist auch nur im Case-Statements sinnvoll, aber nicht in einer verschachtelten Schleife. Wie gesagt, unsaubere Programmierung. Es gibt "schönere" Lösungen.

[Trap]

http://en.wikipedia.org/wiki/Goto

Knuth hat nettes Paper wie man gotos sinnvoll benutzen kann: http://pplab.snu.ac.kr/courses/PL2001/papers/p261-knuth.pdf
Sucht mal für jede Verwendungszweck einen Ersatz, ist ne gute Übung ;)

[ScottManDeath]

IMO kann man in 99% der Fälle das goto durch eine kleverere Formulierung des Algorithmus vermeiden. Es gibt genügend Beispiele für und wider das goto. Wenn es der Übersichtlichkeit dient, dann ja, ansonsten lieber nicht.

Mit Refactoring (http://www.amazon.de/exec/obidos/ASIN/0201485672/qid=1089209641/sr=1-1/ref=sr_1_2_1/028-0818249-2730102) kommt man ausserdem selten in die Verlegenheit z.b. mehrere tief verschachtelte Schleifen zu haben da man u.A. Schleifen auf mehrere Funktionen verteilt um die Qualität des Codes zu "verbessern".


Ich bin bis jetzt (ich programmiere seit >8 Jahren) immer ohne ausgekommen. =)

[noid]

goto?
wofür?

goto ist so beliebt wie globale variablen oder uneingerückter quelltext.

[Xmas]

Oder auch Einrücken mit Spaces ;)


Original geschrieben von Trap
Code-Konventionen sind IMO total unsinnig. Theoretisch kann man 99% der Konventionen vollautomatisch umsetzen. Warum sollte man das als Programmierer machen, der Computer kann das schneller und fehlerfreier.
Stimmt, in den meisten Fällen geht das. Nur sinnvolle Variablennamen muss man noch vergeben, und Kommentare nicht wild in den Code setzen.

In dieser Hinsicht war QuickBasic früher ganz gut, und ich frage mich, warum auch in modernen IDEs automatische Code-Formatierung kaum umfassend zu finden ist.

[Blumentopf]

Ich find GoTo in Ordnung.

Ich verwende es häufig in Assembler alias JMP, JE, JNE, @B, @F; insofern man GoTo mit JMP gleichsetzen kann ;)
Bei einer komplizierten Schleife wirds recht unleserlich, wie soll ichs aber sonst machen in Assembler?

In HLL vermeid ich es natürlich. In VB hat es seinen Einsatz bei Fehler: On Error Goto = ist auch akzeptiert und o.k.

[noid]

das du sprünge in assembler brauchst will ja niemand bestreiten ;)
aber in ein hochsprache hat ein goto nichts verloren.

@Xmas: so gut wie alle editoren, die ich benutze haben sowas wie ein autoformat, was mir die ausricht- und tipparbeit erleichtert.
oder soll ich meinen code einfahc so eintippen und der formatiert? ich persönlich finde das nicht gut, da ich da selbst den überblick verliere.

[PH4Real]

Original geschrieben von noid
oder soll ich meinen code einfahc so eintippen und der formatiert? ich persönlich finde das nicht gut, da ich da selbst den überblick verliere.

Yepp... genauso macht das zum Beispiel die Eclipse IDE (Strg + Shift + F) und Visual Studio .NET kann das Ganze etwas eingeschränkt. Da man ja vorher in den Einstellungen die Formatoptionen genau einstellen kann, ist das eigentlich ziemlich bequem und praktisch.

Besonders, wenn man etwas von CVS auscheckt und nicht gut formatiert ist. Einmal Strg+Shift+F gedrückt und fertig...

Die Konventionen sind jedoch immer noch notwendig. Hauptsächlich für die Namenskonventionen von Variablen, Methoden, Klassen etc.

[Xmas]

IMO ist es mit dem Code-Formatieren genauso wie mit dem Formatieren von Text in Webseiten. Weil z.B. jeder andere Fensterbreiten hat, sollte man keine harten Zeilenumbrüche in Fließtext einbauen. Ähnlich finde ich es z.B. unsinnig, jemand anderem vorschreiben zu wollen, wie er überlange Codezeilen zu lesen hat. Oder wo Klammern zu stehen haben.

Bei den meisten Programmiersprachen kann man Content und Formatierung hervorragend trennen, weil sie "formatfrei" sind. Wieso sollte man also nicht die Möglichkeit haben, Code so zu betrachten und zu bearbeiten, wie man es gerne möchte, ganz egal wer sich vorher daran versucht hat.

Probleme gibt es bei zwei Punkten, einmal bei "Inline-Kommentaren" (für die man sich sowieso was besseres überlegen sollte), und bei Code-Stücken die tabellarisch aussehen sollten, z.B. bei einer Array-Initialisierung. Genau das wäre dann aber wieder ein Verwendungszweck für die Tab-Taste, denn wenn man automatische Formatierung hat, braucht man die Tab-Taste ja zum Einrücken nicht mehr.

Man stelle sich vor, bei einer Array-Initialisierung muss ein Wert geändert werden, der nun breiter ist als der alte, und die IDE passt die Spaltenbreite in allen Zeilen automatisch an! Das wär doch mal was.

[Inquisitor]

Hey, ich hab programmieren auf dem C64 und dessen BASIC gelernt. Da ging mir der GOTO-Befehl in Fleisch und Blut über. Ist jetzt ganz schön schwer "umzulernen". Lern grad C,C++ und Java...

[Matti]

Original geschrieben von Einfachkrank
Die oben dargestellte doppel For-Schleife ist ja ne gezählte Schleife, also könnte man auch das "goto LabelnachderSchleife" durch ein "SetzebeideZähleraufMaximum" ersetzen...

Meine Frage dazu: Was ist schneller?

Goto ist erstens wesentlich schneller und zweitens übersichtlicher! Wenn du die Zähl-Variable auf Maximum setzt, weiß erst mal niemand wieso. Bei einem Sprung sieht aber jeder: hier wird die Schleife verlassen.



Und was hier einige behaupten, zeugt von 0-Programmier-Erfahrung. Daß man es mit Sprüngen nicht übertreiben sollte stimmt, aber es gibt Fälle, wo ein Goto definitiv sauberer ist, als irgendwie hintenrum mit Trick17 irgendwo hinzukommen.

Zu viele Gotos sind schlechter Stil, Gotos sinnvoll eingesetzt sind guter Stil!

[noid]

Original geschrieben von Matti
Goto ist erstens wesentlich schneller und zweitens übersichtlicher! Wenn du die Zähl-Variable auf Maximum setzt, weiß erst mal niemand wieso. Bei einem Sprung sieht aber jeder: hier wird die Schleife verlassen.



Und was hier einige behaupten, zeugt von 0-Programmier-Erfahrung. Daß man es mit Sprüngen nicht übertreiben sollte stimmt, aber es gibt Fälle, wo ein Goto definitiv sauberer ist, als irgendwie hintenrum mit Trick17 irgendwo hinzukommen.

Zu viele Gotos sind schlechter Stil, Gotos sinnvoll eingesetzt sind guter Stil!

hoch lebe der spaghetti-code. lieber mal alles neu schreiben weils keiner mehr versteht, oder die sprünge undurchschaubar werden. debuggen ein horror.
ich kenn genug leute mit erfahrung, die dir alle nen einlauf für nen goto verpassen würden.
außerdem kennt man auch noch andre konstrukte außer geschachtelten for-schleifen.

[HellHorse]

Original geschrieben von Xmas
...
Etwas extremer:
http://www.third-bit.com/~gvwilson/xmlprog.html

[Matti]

mal an alle Goto-ist-immer-Scheiße-Vertreter:

Welche Möglichkeit gibt es, eine geschachtelte Schleife zu verlassen, die übersichtlicher als Goto ist?

Was ist an maximal 2 Gotos pro Funktion unübersichtlich?

In Fällen, wo Goto einfacher und übersichtlicher ist, als andere Methoden, wieso sollte man es dann nicht verwenden?

...wenn ihr mir diese 3 Fragen sinnvoll und nachvollziehbar beantworten könnt, werde ich meine Meinung ändern. Wenn nicht, solltet IHR vielleicht eure Meinung ändern und nicht so sehr pauschalisieren!

[Tom Servo]

Hier mal ein Stück von mir geschriebenen C-Code mit Gotos. Viel Spaß beim Verbessern durch Goto-Entfernung. Ich hatte den Code ursprünglich ohne Gotos geschrieben und er war zu kompliziert und fehleranfällig. Performance spielt keine Rolle.

Ist aus einem Treiber und soll über alle PCI Karten iterieren und bei jeder gefundenen Karte zum Aufrufer zurückehren und beim nächsten Aufruf die Iteration fortsetzen.

Nachdem die Iteration bei einem User auf seiner Hardware-Konfiguration mittendrin abgebrochen ist, habe ich die Goto-Version gemacht die dann auf Anhieb funktioniert hat. Der Grund wird sein, dass es dank Goto nun 3 saubere for-Schleife sind, ohne irgendwelche terminate-Variablen oder gar Manipulationen der Schleifen-Variablen (übrigens eine Sache die IIRC laut "Code Complete" mindestens genauso schlimm ist wie Goto).





case IOCTL_WINIO_GETPCICOMMHDR:
OutputDebugString("IOCTL_WINIO_GETPCICOMMHDR");

if (inBufSize != sizeof (struct winio_pci_common_header_)) {
irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
break;
}

{
struct winio_pci_common_header_ pci_hdr;
enum { pci_data_size = ((sizeof pci_hdr) - FIELD_OFFSET(struct winio_pci_common_header_, VendorID)) };
PPCI_COMMON_CONFIG pci_data;

memcpy(&pci_hdr, ioBuf, min(sizeof pci_hdr, inBufSize));
pci_data = (PPCI_COMMON_CONFIG)&pci_hdr.VendorID;

// If this is not first call, continue iteration at the same place where we leaved last time
if (pci_data->VendorID != 0) goto next_fn; // -*- jump into loop -*-

for (pci_hdr.Bus = 0; pci_hdr.Bus < 8; ++pci_hdr.Bus) {
for (pci_hdr.Dev = 0; pci_hdr.Dev < PCI_MAX_DEVICES; ++pci_hdr.Dev) {
for (pci_hdr.Fn = 0; pci_hdr.Fn < PCI_MAX_FUNCTION; ++pci_hdr.Fn) {

ULONG result;
PCI_SLOT_NUMBER slot_number = {0};

slot_number.u.bits.DeviceNumber = pci_hdr.Dev;
slot_number.u.bits.FunctionNumber = pci_hdr.Fn;


// skip functions above 0 for single function devices
if (pci_hdr.Fn > 0 && !(pci_hdr.HeaderType & PCI_MULTIFUNCTION)) goto next_dev; // no more functions

result = HalGetBusData(PCIConfiguration, pci_hdr.Bus, slot_number.u.AsULONG, pci_data, pci_data_size);

if (result == 2 && pci_data->VendorID == PCI_INVALID_VENDORID) goto next_fn; // device or function does not exist
else if (result == 0) goto next_bus; // bus does not exist
else goto found_fn; // Device found

next_fn: continue; } // fn
next_dev: continue; } // dev
next_bus: continue; } // bus


pci_hdr.Bus = ~0; // no more busses. done.
found_fn:
memcpy(ioBuf, &pci_hdr, min(sizeof pci_hdr, inBufSize));
irp->IoStatus.Information = inBufSize;
irp->IoStatus.Status = STATUS_SUCCESS;
}

OutputDebugString("Leaving IOCTL_WINIO_GETPCICOMMHDR");
break;

[massa]

Mal ne andere Frage...

Warum sollte ich eine For-schleife verwenden, wenn ich diese aufgrund einer bestimmten Bedingung abbreche? For-schleifen nutze ich doch dann, wenn ich eine ganz bestimmte Anzahl an Durchläufen habe... fertig.
Für alles Andere gibts While-schleifen mit Abbruchbedingung. Ich muss da auch keinen Zähler manipulieren. Einfach nen kleinen Schalter rein fürn Abbruch fertig...

Da kann mir dann Keiner erzählen ein GoTo in einer For-schleife wäre übersichtlicher...

Ist denn die Performance soviel besser bei der GoTo Version?

[Xmas]

Original geschrieben von massa
Mal ne andere Frage...

Warum sollte ich eine For-schleife verwenden, wenn ich diese aufgrund einer bestimmten Bedingung abbreche? For-schleifen nutze ich doch dann, wenn ich eine ganz bestimmte Anzahl an Durchläufen habe... fertig.
Für alles Andere gibts While-schleifen mit Abbruchbedingung. Ich muss da auch keinen Zähler manipulieren. Einfach nen kleinen Schalter rein fürn Abbruch fertig...
Vielleicht weil in der Schleife trotzdem ein Zähler gebraucht wird?

Davon abgesehen ist
for(a; b; c)
{
...
}
lediglich syntaktischer Zucker für
a;
while(b)
{
...
c;
}

[x-dragon]

Original geschrieben von Matti
Man sollte es mit goto nicht übertreiben, aber es gibt Situationen, wo ein Sprung eben einfacher und übersichtlicher ist:
...
ohne goto müßte man eine zusätzliche Status-Variable einführen (langsam und unübersichtlich) oder die verschachtelte Schleife in eine extra Funktion packen (unübersichtlich und minimal langsamer). Danke für den Tip :up:. Diese zusätzlichen Statusvariablen gingen mir nämlich auch ziemlich auf den Keks, aber bin bisher auch noch nicht auf die Idee gekommen in Pascal/Delphi einen Goto-Befehl zu verwenden (kannte ihn bisher auch nur von BASIC) ...

[massa]

@Xmas
was hat das denn mit dem Zähler in der Iteration zu tun?
Ist schon klar, dass ich den so oder so brauche.

Mir gehts doch darum, dass ich bei einer While-Schleife eine Abbruchbedingung einbauen kann und bei einer For eben nicht. Also macht es doch keinen Sinn auf Gedeih und Verderb eine For-Schleife einzubauen wenn ich bei einer Bestimmten Bedingung die Schleife abbrechen oder lieg ich da so falsch?

Gruß massa

[Xmas]

Original geschrieben von massa
@Xmas
was hat das denn mit dem Zähler in der Iteration zu tun?
Ist schon klar, dass ich den so oder so brauche.

Mir gehts doch darum, dass ich bei einer While-Schleife eine Abbruchbedingung einbauen kann und bei einer For eben nicht. Also macht es doch keinen Sinn auf Gedeih und Verderb eine For-Schleife einzubauen wenn ich bei einer Bestimmten Bedingung die Schleife abbrechen oder lieg ich da so falsch?

Gruß massa
In C/C++/C#/Java/etc. kann man bei for eben doch eine Abbruchbedingung einbauen. Schau dir mein Beispiel nochmal an. Wenn du einen Zähler brauchst, ist die Schreibweise mit for schlicht kompakter, funktional aber vollkommen identisch.

[massa]

oha.... hab ich so noch nie drüber nachgedacht...

d.h. also, wenn ich mein For z.b. so formuliere:

for(i=0;uprog==1;i++)

//uprog wäre z.b. eine Funktion die mir einen Rückgabewert //liefert... meinet wegen eine Plausiabfrage


dann würde das funktionieren?

[Xmas]

uprog(), wenn es eine Funktion ist, aber ansonsten ja, ist gültiger C-Code.

[Karlsson]

:uhippie:

[massa]

*ankopfklatsch*
klar klammern.... :D

dann mal danke für die neue erkenntnis *g*