Verfügbare Informationen zu "gcc Fehler: WTF???"
Qualität des Beitrags: Beteiligte Poster: DrPhil_Guth - Dirty Oerty - Xin Forum: Tutorials.at Forenbeschreibung: Programmierforum aus dem Unterforum: Off-Topic Antworten: 8 Forum gestartet am: Mittwoch 19.04.2006 Sprache: deutsch Link zum Originaltopic: gcc Fehler: WTF??? Letzte Antwort: vor 16 Jahren, 4 Monaten, 28 Tagen, 12 Stunden, 53 Minuten
Alle Beiträge und Antworten zu "gcc Fehler: WTF???"
Re: gcc Fehler: WTF???
DrPhil_Guth - 16.09.2007, 11:57gcc Fehler: WTF???
Hi!
Vor längerer Zeit gabs mal ne kleine Diskussion über Compiler, in der Xin meinte dass gcc völlig unverständliche fehlermeldungen auswirft.
Ich in meiner Begeisterung habe das natürlich als unfug abgetan.
Naja, nichtsdestotrotz wurde ich eines besseren belehrt. Hier habe ein kleines "schmankerl" von gcc. Bitte zurücklehnenen und genießen:
gcc hat folgendes geschrieben: g++ -o optsreader_test optsreader_test.o optsreader_base.o
optsreader_test.o: In function `std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::get_value<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)':
optsreader_test.cpp:(.text._ZN10optsreader11COpts_Plain9get_valueISsEET_RSs[std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::get_value<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0xc9): undefined reference to `unsigned int optsreader::COpts_Plain::find_value<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)'
optsreader_test.cpp:(.text._ZN10optsreader11COpts_Plain9get_valueISsEET_RSs[std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::get_value<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0x15f): undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::isolate_value<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int)'
optsreader_test.o: In function `double optsreader::COpts_Plain::get_value<double>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)':
optsreader_test.cpp:(.text._ZN10optsreader11COpts_Plain9get_valueIdEET_RSs[double optsreader::COpts_Plain::get_value<double>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0xbe): undefined reference to `unsigned int optsreader::COpts_Plain::find_value<double>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)'
optsreader_test.cpp:(.text._ZN10optsreader11COpts_Plain9get_valueIdEET_RSs[double optsreader::COpts_Plain::get_value<double>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0x154): undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::isolate_value<double>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int)'
optsreader_test.o: In function `bool optsreader::COpts_Plain::get_value<bool>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)':
optsreader_test.cpp:(.text._ZN10optsreader11COpts_Plain9get_valueIbEET_RSs[bool optsreader::COpts_Plain::get_value<bool>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0xbe): undefined reference to `unsigned int optsreader::COpts_Plain::find_value<bool>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)'
optsreader_test.cpp:(.text._ZN10optsreader11COpts_Plain9get_valueIbEET_RSs[bool optsreader::COpts_Plain::get_value<bool>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0x154): undefined reference to `std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::isolate_value<bool>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, unsigned int)'
collect2: ld returned 1 exit status
make: *** [optsreader_test] Fehler 1
Also ich weiß nicht was ihr dazu sagt, aber mein erster Eindruck war nur ein riesengroßes "WTF???"
Nachdem ich mir das teil angesehen habe wusste ich sogar was er wollte, aber ihr müsst zugeben, das ding ist schon ein hammer...
Re: gcc Fehler: WTF???
Dirty Oerty - 16.09.2007, 14:19
Das ist wirklich Hammer....
Du weißt, weshalb er dir DAS ausgespuckt hat?
Verrätst du's uns?
LG
Daniel
Re: gcc Fehler: WTF???
DrPhil_Guth - 16.09.2007, 17:31
Magie... ;)
Wenn ich das jetzt verrate erscheint die sache nicht mehr ganz so mystisch.
Ich tus trotzdem:
also, als ich mir das ding mal genauer angesehen habe habe ich ein muster immer wieder gefunden: Zitat: std::basic_string<char, std::char_traits<char>, std::allocator<char> >
Da dachte ich mir hey, das kenn ich doch! std::string ist nämlich ein typedef für diese lange wurst. Also hab ich alle diese dinger durch std::string ersetzt.
Des weiteren muss man bedenken, dass das genaugenommen kein Compiler- sondern ein Linker- fehler ist. Und das Format der verlinkten dateien haben so ganz komische symbole, beispielsweise: Zitat: (.text._ZN10optsreader11COpts_Plain9get_valueISsEET_RSs[std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::get_value<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0xc9)
Keinen Tau wie die aufgebaut sind, aber ich weiß dass sie mich nicht interessieren. Die hab ich weggelöscht.
Übriggeblieben ist das hier:
Zitat:
optsreader_test.o: In function `std::string optsreader::COpts_Plain::get_value<std::string>(std::string&)':
optsreader_test.cpp: undefined reference to `unsigned int optsreader::COpts_Plain::find_value<std::string >(std::string&, unsigned int, std::string&)'
optsreader_test.cpp: undefined reference to `std::string optsreader::COpts_Plain::isolate_value<std::string >(std::string&, unsigned int)'
optsreader_test.o: In function `double optsreader::COpts_Plain::get_value<double>(std::string&)':
optsreader_test.cpp: undefined reference to `unsigned int optsreader::COpts_Plain::find_value<double>(std::string&, unsigned int, std::string&)'
optsreader_test.cpp: undefined reference to `std::string optsreader::COpts_Plain::isolate_value<double>(std::string&, unsigned int)'
optsreader_test.o: In function `bool optsreader::COpts_Plain::get_value<bool>(std::string&)':
optsreader_test.cpp: undefined reference to `unsigned int optsreader::COpts_Plain::find_value<bool>(std::string&, unsigned int, std::string&)'
optsreader_test.cpp: undefined reference to `std::string optsreader::COpts_Plain::isolate_value<bool>(std::string&, unsigned int)'
collect2: ld returned 1 exit status
Naja, und das ist doch fast lesbar oder?
Worin der Fehler ws. liegt:
ich hatte eine Template- deklaration und eine Template implementierung.
Die deklaration konnte anscheinend aufgelöst werden, also könnte man sagen die funktionsköpfe für die einzelnen typen sind vorhanden.
Die Auflösung der implementierungen hat aus irgend einem grund nicht funktioniert, somit haben wir zwar ein paar funktionsköpfe, das heißt es gibt schon mal keine compilerfehler. Allerdings die funktionen selber gibts nicht, das bedeutet "undefined reference".
Leider hab ichs bis jetzt nicht geschafft den fehler vereinfacht zu reproduzieren, denn ich habe ne kombination aus templates, vererbung und virtuellen memberfunktionen. Und wenn ich da ne beispielklasse schreibe wird die ws. ungefähr gleich lang wie das original... :(
Re: gcc Fehler: WTF???
Xin - 20.11.2007, 01:06
DrPhil_Guth hat folgendes geschrieben: Hi!
Vor längerer Zeit gabs mal ne kleine Diskussion über Compiler, in der Xin meinte dass gcc völlig unverständliche fehlermeldungen auswirft.
Ich in meiner Begeisterung habe das natürlich als unfug abgetan.
Da habe ich kein Problem mit. Die Erkenntnis, dass ich nicht nur Unfug rede, wächst bei den meisten über die Jahre. Der Schnitt liegt bei drei Jahren.
Die Tatsache, dass ich inzwischen einen Durchschnitt habe, erklärt vielleicht schon, wieso ich mich nicht darum kümmere, ob jemand mein Gerede für Unfug hält.
DrPhil_Guth hat folgendes geschrieben: also, als ich mir das ding mal genauer angesehen habe habe ich ein muster immer wieder gefunden: Zitat: std::basic_string<char, std::char_traits<char>, std::allocator<char> >
Da dachte ich mir hey, das kenn ich doch! std::string ist nämlich ein typedef für diese lange wurst. Also hab ich alle diese dinger durch std::string ersetzt.
Das macht die Meldung lang, aber nicht unverständlich. Man könnte sie vielleicht hübscher formatieren... ^^
DrPhil_Guth hat folgendes geschrieben: Des weiteren muss man bedenken, dass das genaugenommen kein Compiler- sondern ein Linker- fehler ist. Und das Format der verlinkten dateien haben so ganz komische symbole, beispielsweise: Zitat: (.text._ZN10optsreader11COpts_Plain9get_valueISsEET_RSs[std::basic_string<char, std::char_traits<char>, std::allocator<char> > optsreader::COpts_Plain::get_value<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)]+0xc9)
Keinen Tau wie die aufgebaut sind, aber ich weiß dass sie mich nicht interessieren. Die hab ich weggelöscht.
*g* So geht's natürlich auch.
Du kannst in C++ Funktionen überladen:
Code:
int addiere( int a, int b );
int addiere( int a, int b, int c );
Möchte man nun eine der Funktionen anspringen, ist der Name der Funktion ein Alias für die Adresse, zu der man springt. Nun hat man blöderweise das Problem, dass man zwei Funktionen hat, aber nur einen Namen.
Einfach durchzählen darf der Compiler aber auch nicht, da eine DLL/so ja nicht abhängig von der Reihenfolge der Funktionen im Sourcecode sein kann. Also kodiert man die Typen der Parameter mit in den Funktionsnamen.
In vielen DLL/sos ist das Verhalten unerwünscht, daher verzichtet man bei den Funktionen, die die Library anbietet auf Überladung und kennzeichnet das Interface als "C"-Interface, da man in C noch nicht überladen konnte.
Code:
extern "C"
{
int addiere2( int a, int b );
int addiere3( int a, int b, int c );
}
In dem Fall zähle ich von Hand durch, das bedeutet für den Compiler aber, dass ich für jede Funktionen einen eindeutigen Namen habe - also eben nicht mehr überlade.
Re: gcc Fehler: WTF???
DrPhil_Guth - 23.11.2007, 21:42
Danke, das weiß ich mittlerweile. Trotzdem musst du zugeben, dass diese funktionsnamen die mit "name mangling" verändert wurden doch eher kryptischen charakter haben... Hab mir die Arbeit das zu entschlüsseln einfach nicht antun wollen...
Naja, zum fehler: :evil: :evil: :evil:
ICH HASSE IHN!!! Das ding hat mir 2-3 wochen meines Lebens gekostet, hat das ganze Projekt auf Spiel gesetzt (großer großer Frust faktor).
Und was wars am ende?
Das hier:
Code:
class SomeClass
{
void doSomething();
}
void doSomething()
{
// do nothing
}
einfach nur SomeClass:: vergessen. :(
Naja, wie auch immer, aus dem Projekt ist jetzt ne hübsche kleine Optionsleserbibliothek geworden, funktioniert sogar :-)
Re: gcc Fehler: WTF???
Xin - 24.11.2007, 11:44
DrPhil_Guth hat folgendes geschrieben: Danke, das weiß ich mittlerweile. Trotzdem musst du zugeben, dass diese funktionsnamen die mit "name mangling" verändert wurden doch eher kryptischen charakter haben...
Zugeben muss man etwas, was man verbrochen hat.
Zum einen habe ich das nicht verbrochen, zum anderen schreibe ich einen Compiler und wäre interessiert, wie Du das Thema angehen würdest. ^^
DrPhil_Guth hat folgendes geschrieben: Naja, zum fehler: :evil: :evil: :evil:
ICH HASSE IHN!!! Das ding hat mir 2-3 wochen meines Lebens gekostet,
Das solltest Du positiv sehen: Du wirst diesen Fehler zukünftig schneller finden. Ansonsten sind drei Wochen noch akzeptabel, solange Du dafür nicht bezahlt wirst. Machst Du den Fehler da, heißt das im Prinzip unbezahlt suchen, weil sowas bezahlt Dir keiner.
Ich habe mal 8 Wochen nach einem Fehler gesucht und das dumme war, dass die Debugausgaben den Fehler korrigierten: Beim Debuggen lief alles super, ohne Debugging keine Debuginformation, dafür Fehler...
Das frustet auch leicht.
Die lexikalische Analyse meines Compilers (auf Deutsch: Och guck, ein Wort "if", das habe ich schonmal gesehen) kopiert keine Strings aus dem Sourcecode, sondern schreibt hinter das Wort "if" ein Nullbyte mitten in den Sourcecode. Damit gibt's einen vollständigen String "if", den ich schnell gegen alle bekannten Worte vergleichen kann. Um den Sourcecode weiter zu lesen, muss das Nullbyte aber wieder verschwinden, sonst wäre an der Stelle der Sourcecode zu Ende. Und das Nullbyte habe ich bei den Debugausgaben immer brav zurückgesetzt, aber ein einer von vielen Stellen nicht durch den Compiler. Also funktionierten die folgenden Anweisungen nur dann, wenn ich den Compiler debuggte.
Konsequenz daraus: Der Mensch ist zu blöd, um daran immer zu denken, also geschieht es jetzt automatisch.
Ansonsten habe ich auch mal 8 Wochen damit verbracht einem
malloc( strlen( String ) ); auf die Schliche zu kommen. Leider kein Platz für ein Nullbyte mehr, ergo Peng!
Wobei Peng abhängig von der Stringlänge war. Mal funktionierte es - mal nicht.
DrPhil_Guth hat folgendes geschrieben: hat das ganze Projekt auf Spiel gesetzt (großer großer Frust faktor).
Darum sage ich jedem, der Programmieren lernen möchte, dass er durch das laaange, sehr lange, frustrierende Tal der Tränen muss, bevor er programmieren kann.
Wenn Du Dich 3 Wochen durchbeißen kannst, wirst Du den Weg wohl gehen können.
DrPhil_Guth hat folgendes geschrieben: Code:
class SomeClass
{
void doSomething();
}
void doSomething()
{
// do nothing
}
einfach nur SomeClass:: vergessen. :(
Niedlich.
Wenn der Linker meckert heißt das in der Regel "Funktion unbekannt" oder "Funktion mehrfach vorhanden". Viel mehr meckert ein Linker nicht mehr an.
DrPhil_Guth hat folgendes geschrieben: Naja, wie auch immer, aus dem Projekt ist jetzt ne hübsche kleine Optionsleserbibliothek geworden, funktioniert sogar :-)
Was ist eine Optionsleserbibliothek?
Re: gcc Fehler: WTF???
DrPhil_Guth - 25.11.2007, 11:34
Xin hat folgendes geschrieben:
Zugeben muss man etwas, was man verbrochen hat.
Zum einen habe ich das nicht verbrochen, zum anderen schreibe ich einen Compiler und wäre interessiert, wie Du das Thema angehen würdest. ^^
Ich würde das genau so angehen, wenn ich Compiler schreiben will. Wenn ich allerdings einfach nur mein Programm Debugge, dann muss ich zugeben ( ;) ) dass mich diese anhäufung von fast unlesbaren Zahlen und Buchstaben genug abschreckt um es nicht zu analysieren. Die einzige information die ich außerdem dadurch bekommen habe, wäre gewesen "funktion x in datei y nicht gefunden", und das habe ich durch die anderen debugausgaben auch gewusst.
Xin hat folgendes geschrieben:
Wenn der Linker meckert heißt das in der Regel "Funktion unbekannt" oder "Funktion mehrfach vorhanden". Viel mehr meckert ein Linker nicht mehr an.
Das ist Klar. Nur sind die Gründe wieso eine Funktion nicht gefunden werden kann sehr unterschiedlich.
Und ich in diesem Projekt mehr oder weniger zum ersten mal Templates "richtig" benutzt habe, und auch schon davor Probleme mit Templates/Linker gehabt habe, hab ich nicht an sowas simples gedacht.
Xin hat folgendes geschrieben:
Was ist eine Optionsleserbibliothek?
Das ist so ungefähr eine vorvorvorvorvorstufe zu deinem Compiler. Du hast ne Datei, da stehen optionen drinnen, beispielsweise so:
Code: #das ist ein Kommentar
size_of_string 128
und willst das irgendwie in dein Programm kriegen. Mit meiner "mini-bibliothek" geht das ganz einfach:
Code: unsigned int size_of_string;
std::string filename("config.txt");
std::string keyword("size_of_string");
optsreader::COpts_Plain optsfile;
// Datei laden
opsfile.load(filename);
// Wert extrahieren
size_of_string = optsfile.get_value<unsigned int>(keyword);
und schon hat man den Wert der gerade noch in der Datei war in die Variable gespeichert. Falls ein fehler auftrat wird eine Exception geworfen, die einen Zahlencode und einen String mit dem Grund des Problems enthält.
Naja, ist vielleicht etwas mickrig aber ich bin stolz darauf, weil das erstens nicht nur "C mit Klassen" ist weil ich auch Templates, Exceptions und Stringstreams verwendet habe, außerdem kann man es recht leicht erweitern. (Beispielsweise würde für einen eigenen Datentyp sogar eine einfache überladung von operator<<() reichen.)
Re: gcc Fehler: WTF???
Xin - 25.11.2007, 14:12
DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben:
Zugeben muss man etwas, was man verbrochen hat.
Zum einen habe ich das nicht verbrochen, zum anderen schreibe ich einen Compiler und wäre interessiert, wie Du das Thema angehen würdest. ^^
Ich würde das genau so angehen, wenn ich Compiler schreiben will.
Mich interessiert nicht, was für den Compilerentwickler einfacher ist, sondern was Du als Information lesen willst und ob Du es für möglich erachtest, die Information, die Du lesen willst, aus dem Programm algorithmisch lesen zu können.
Dass Compilerentwickler sich das Leben auch gerne leicht machen, weiß ich, ich meckere nicht umsonst über die Qualität der Fehlermeldungen.
DrPhil_Guth hat folgendes geschrieben: Wenn ich allerdings einfach nur mein Programm Debugge, dann muss ich zugeben ( ;) ) dass mich diese anhäufung von fast unlesbaren Zahlen und Buchstaben genug abschreckt um es nicht zu analysieren.
Selbst schuld. Warum verwendest Du auch strings, die in einem endlosen Template-Stammbaum enden. Schreib Dir eine Fassade (hier könnte eine URL stehn, würde das Forum dann nicht zusammenbrechen, schau halt bei Wikipedia unter Fassade (Entwurfsmuster) nach).
Ich hab's aufgegeben, weil std::string nicht viel taugt und weil mich die (char const *)-Strings auch nicht glücklich machen, habe ich angefangen eine brauchbare Stringklasse zu schreiben.
Ist 'ne nette Übung, seit letzter Woche in meinem Compiler eingebaut und funktioniert auch - kann nur mehr und ergibt keine katastrophalen Linkermeldungen.
DrPhil_Guth hat folgendes geschrieben: Die einzige information die ich außerdem dadurch bekommen habe, wäre gewesen "funktion x in datei y nicht gefunden", und das habe ich durch die anderen debugausgaben auch gewusst.
Welche anderen Debugausgaben?
Das Programm ist kompilierbar, aber nicht linkbar, also nicht ausführbar, somit auch nicht debugbar und das wiederum ist furchtbar, wenn die Linkerausgaben nicht lesbar sind.
DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben:
Wenn der Linker meckert heißt das in der Regel "Funktion unbekannt" oder "Funktion mehrfach vorhanden". Viel mehr meckert ein Linker nicht mehr an.
Das ist Klar. Nur sind die Gründe wieso eine Funktion nicht gefunden werden kann sehr unterschiedlich.
Ich bin Meister im Schnellverstecken von alläglichen Dingen, wie Portemonee oder Schlüssel. Die Gründe sind so vielfältig, wie die Verstecke. Wenn Du nach 3 Tagen Suche die Fernbedienung Deines Verstärkers im Kühlschrank wiederfindest, hast Du einen Grund, warum Du sie nicht an den Stellen gefunden hast, wo Du sie vermutet hast und zusätzlich eine Frage, wieso Du sie 3 Tage im Kühlschrank übersehen hast. Es löst aber Dein Problem nicht: Wie komme ich an die Information warum die Fernbedienung unauffindbar ist, bevor ich weiß wo die Fernbedienung auffindbar ist.
Wenn Du die Frage beantworten kannst, was ich tun muss, die Fernbedienung zu finden, ohne erst mehrfach meine Wohnung umzugraben, um zu erkennen, dass sie da nicht liegt, würde mir das beim nächsten Mal sehr helfen.
Du kannst nur lernen.
Wenn ich meine Fernbedienung, Schlüssel oder Portemonee suche, schaue ich jetzt auch in den Kühlschrank. Oder den Zeitungen im Bad. Hinterm Bett und überall da, wo sie überraschenderweise nach einigen Tagen, Wochen oder Monaten wieder auftauchte.
Für meine Hausschlüssel habe ich vorsichtshalber ein Backup. ;-)
So wird man ein erfahrener Sucher. Oder Programmierer.
DrPhil_Guth hat folgendes geschrieben: Naja, ist vielleicht etwas mickrig aber ich bin stolz darauf, weil das erstens nicht nur "C mit Klassen" ist weil ich auch Templates, Exceptions und Stringstreams verwendet habe, außerdem kann man es recht leicht erweitern. (Beispielsweise würde für einen eigenen Datentyp sogar eine einfache überladung von operator<<() reichen.)
Wenn man's richtig anstellt, finde ich das gar nicht mickrig, ich habe ähnliches auch mal geschrieben, allerdings muss man die Werte nicht mehr von Hand aus dem Datensatz auslesen, das Objekt wird automatisch ausgelesen bzw. beschrieben. Das brauchbar hinzubekommen fand ich schon aufwendiger.
Ich rate zur Vorsicht mit Exceptions. Exceptions sind eine interessante Erfindung. Leider begeht imho 99,9% der Programmierer den Fehler, das alles, was nicht normal abläuft eine Ausnahme wäre.
Man stelle sich vor, dass jemand der im Straßenverkehr sich nicht an die Regeln hält eine Exception wäre. Oder Kinder, die unbedarft auf die Straße hüpfen. Es ist so regelmäßig, dass es eben keine Exception ist. Wenn überall Ausnahmen zu erwarten sind - wie es in Java die Regel ist - wird man Ausnahmen irgendwann nicht mehr beachten, weil man sich nunmal auf den Normalfall konzentriert - wie es in Java die Regel ist.
Würden Führerscheine in Java geschrieben, würden wir reihenweise Unfälle haben, weil wir Exceptions zwar abfangen müssen, dann aber nicht beachten.
ACHTUNG KIND AUF DER STRASSE - Was ist zu tun? Nichts. Ja, dann fahren wir halt drüber.
Schonmal ein Programm gesehen, dass Dir freundlich mitteilt, dass es grade abgeschmiert ist, Deine Daten im Arsch sind und Du das Programm bitte neustarten sollst?
Schon wieder ein überfahrenes Kind...
Schreib eine brauchbare API. Es spielt keine Rolle, ob Du Rückgabewerte nicht prüfst, oder Exceptions ignorierst. Rückgabewerte nicht prüfen geht aber schneller, als Exceptions auswerten, um dann nicht darauf zu reagieren.
Elegant wird ein Algorithmus erst, wenn er auch fehlertolerant richtig funktioniert. Exceptions sind Ausnahmen. Ausnahmen sind Fehlerquellen und Fehlerquellen schaffen Sonderbedingungen, um Ausnahmen zu bearbeiten. Das verkompliziert den Algorithmen welcher damit größer wird und damit noch fehleranfälliger wird.
Irgendjemand hat hier den Spruch "Die dümmsten Programmierer haben die längsten Programme". Der Spruch ist wahr.
Exceptions sind grundsätzlich keine Fehlentwicklung. Aber die Verwendung von Exceptions macht daraus eine Fehlentwicklung.
Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken
Weitere Beiträge aus dem Forum Tutorials.at
Problem beim Programm... - gepostet von toby-man am Mittwoch 03.10.2007
Zufälligkeit - gepostet von vpascal am Donnerstag 09.08.2007
Sound über die Bios BOX (Alle meine Entchen) - gepostet von Tro1aner am Montag 22.01.2007
Lottozahlengenerator - gepostet von Mucky am Sonntag 11.02.2007
Voice Controll - gepostet von Dirty Oerty am Donnerstag 12.04.2007
Unterschied zwischen void Funktion und andere Funktionen - gepostet von EndSub am Montag 10.07.2006
Tutorias für Grafiken in C - gepostet von mitti am Donnerstag 26.04.2007
Ähnliche Beiträge wie "gcc Fehler: WTF???"
Fehler oder notwendige Änderungen auf der Hompage - Christoph Weikl (Dienstag 09.05.2006)
kleiner fehler? - deadenddreaming (Dienstag 02.05.2006)
Fehler - unstopable (Freitag 14.07.2006)
Mullen's Apply >____________> (WTF) - M u l l e n's (Dienstag 18.09.2007)
Fehler!!! - administrator (Montag 01.10.2007)
Muss man bei eigenen Fehler selbst zahlen? - Cheryn Light (Donnerstag 05.07.2007)
Fehler beim Builden - lanzet3 (Samstag 19.06.2004)
Fehler im Projekt - andreasw (Mittwoch 30.11.2005)
The Frida and Agnetha meta-list (list of lists) - Emmanuelle (Sonntag 01.08.2010)
Fehler - Geigi (Dienstag 17.07.2007)