|
|
|
|
|
|
|
Ich meine den Part der zur Compilezeit passiert.
Ich habe so gut wie keine Erfahrung mit Debuggern in der C-Welt muss ich zugeben.
e/ Ein wenig expliziter: Ich benutze atm Eigen und die Fehlermeldungen tendieren ab und an dazu mehere hundert Zeilen lang zu werden. Meistens kann man ganz gut raten wo das Problem ist (sie geben sich ja auch alle Mühe das irgendwie klar zu machen), aber ich frage mich wie die Leute die Eigen schreiben an ihrem Code rumwerkeln.
Das ganze ist nicht ganz uneigennützig, da ich was in der richtung demnächst evtl brauchen werde.
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von B0rG* am 13.06.2013 22:46]
|
|
|
|
|
|
|
|
|
| | Zitat von nobody
Dienstag Abgabe? Hast du nicht gerade erst angefangen?
Wie auch immer, frohes schaffen.
| |
Ihr könnt euch wohl nicht entscheiden wie?
- WAAAS, erst Diplomarbeit, du bist doch schon eeeeewig Student!
- Was, du gibst bald ab?!
...
Mal sehen, in welcher Staffel ich bei Voyager am Dienstag bin.
Ob ich die niedliche Chinesin dazu einladen schaffe...?
Hast du entdeckt, dass Frauenbeine keine Tischbeine sind? Na bravo!
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von B0rG*
Ich meine den Part der zur Compilezeit passiert.
Ich habe so gut wie keine Erfahrung mit Debuggern in der C-Welt muss ich zugeben.
e/ Ein wenig expliziter: Ich benutze atm Eigen und die Fehlermeldungen tendieren ab udn an dazu mehere Hunder Zeilen lang zu werden. Meistens kann man ganz gut raten wo das Problem ist (sie geben sich ja auch alle Mühe das irgendwie klar zu machen), aber ich frage mich wie die Leute die Eigen schreiben an ihrem Code rumwerkeln.
Das ganze ist nicht ganz uneigennützig, da ich was in der richtung demnächst evtl brauchen werde.
| |
Bei Eigen hilft meistens die erste Zeile der Fehlermeldung anzuzeigen und gut überlegen, was man macht
Nachher kommen halt meistens "Folgefehler". Du kannst halt keine Breakpoints beim Kompilieren setzen, deshalb brauchst du eine starke IDE; mit VS und Visual assist funktioniert schon recht anständig
|
|
|
|
|
|
|
|
|
|
| | Zitat von RichterSkala
Hilfe, ich beginne Interesse an Carbonnanotubes zu entwickeln 
| |
Benutze altes ausgeleiertes Thema, das völlig in Vergessenheit geraten ist, kaufe ein paar CNTs oder Graphen, lege sie/es drauf, drüber, drunter oder hinein -> Instantpaper!
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von _Ac_
| | Zitat von B0rG*
Ich meine den Part der zur Compilezeit passiert.
Ich habe so gut wie keine Erfahrung mit Debuggern in der C-Welt muss ich zugeben.
e/ Ein wenig expliziter: Ich benutze atm Eigen und die Fehlermeldungen tendieren ab udn an dazu mehere Hunder Zeilen lang zu werden. Meistens kann man ganz gut raten wo das Problem ist (sie geben sich ja auch alle Mühe das irgendwie klar zu machen), aber ich frage mich wie die Leute die Eigen schreiben an ihrem Code rumwerkeln.
Das ganze ist nicht ganz uneigennützig, da ich was in der richtung demnächst evtl brauchen werde.
| |
Bei Eigen hilft meistens die erste Zeile der Fehlermeldung anzuzeigen und gut überlegen, was man macht
Nachher kommen halt meistens "Folgefehler". Du kannst halt keine Breakpoints beim Kompilieren setzen, deshalb brauchst du eine starke IDE; mit VS und Visual assist funktioniert schon recht anständig
| |
Hmm achso das meinst du.
Ich würde sagen, dass das primär Erfahrungssache ist.
Den riesigen Rattenschwanz lernt man zu schätzen, weil da letztlich die "Spur" des Fehlers drinsteht, also wo z.B. ein eingesetzter Typ anfängt Fehler zu verursachen.
Tools um Templates zu debuggen sind mir nicht bekannt... wäre wohl auch relativ schwer, weil es bei Templates fast ausschließlich um Logikfehler des Programmierers geht, die ja nun doch relativ schwer erkennbar sind o)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Jo Clang macht oft etwas besser verständliche Fehlermeldungen als GCC & wird auch in einigen IDEs genutzt. Der erzeugte Code ist allerdings schlechter als der vom GCC.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von csde_rats
Jo Clang macht oft etwas besser verständliche Fehlermeldungen als GCC & wird auch in einigen IDEs genutzt. Der erzeugte Code ist allerdings schlechter als der vom GCC.
| |
Was heißt 'schlechter'? Ich habe bisher immer gcc benutzt und bin immer zufrienden gewesen. Ich hab nur mal gehört, dass clang schneller im compilen sei. Willst du dazu etwas schreiben? Würd mich mal echt interessieren, vorallem da ich auf die schnelle keinen interessanten Vergleich gcc va. clang gefunden habe.
|
|
|
|
|
|
|
|
|
|
|
Darf es mich amüsieren, dass jetzt in meiner Bibliographie Einträge wie der folgende sind?
[DeW67]DeWitt, Bryce S. [...] In: DeWitt, Cecile [...]
höhö...
Therefore, those people who say that they can't jack off to anime must have something wrong with their brains!
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von csde_rats
| | Zitat von B0rG*
Apropos: Gibt es irgendeine gescheite Möglichkeit C++-Template Code zu debuggen?
| |
Genauso wie normalen Code?!
| |
also ganz viele cout << "Hier bin ich" << endl;
*muhahahahaha*
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von con_chulio
also ganz viele cout << "Hier bin ich" << endl;
*muhahahahaha*
| |
SO kann ich noch selbst debuggen! 
Alright, the cat's alive - let's go to dinner!
|
|
|
|
|
|
|
|
|
|
Nichtsequentielle Programmierung
|
Folgende Aufgabe:
Drei Klassen verschieden großer Objekte (große, mittlere und kleine) duerfen sich nur nach folgender Regel von A nach B und umgekehrt bewegen: Der Weg zwischen A und B darf zur gleichen Zeit immer nur in einer Richtung benutzt werden; entweder von einem großen, von einem oder zwei mittleren, von einem mittleren und ein bis zwei kleinen oder von hoechstens vier kleinen Objekten.
Entwickeln Sie einen fairen (!) Algorithmus zur Synchronisation der Bewegungen vieler Objekte und begruenden Sie seine Korrektheit.
Dazu habe ich mir folgende Ueberlegungen gemacht:
- jedes Objekt bekommt eine ID, die einfach immer aufsteigend von 0 beginnend vergeben werden und eine Eigenschaft (links oder rechts) mit ihrer Herkunft
- ein Objekt (gross, mittel, klein) hat eine Zahl, die den Platzanspruch repraesentiert (4, 2, 1)
- die herumschwirrenden Objekte sollen sich zu "Clustern" zusammenfinden, also einer uebergeordneten Struktur, die "4" Platz bietet. Damit sollen die Objekte portioniert werden fuer den Transfer
- ein fertiger Cluster enthaelt eine Zahl, die die Summe der IDs der in ihm enthaltenen Objekte ist
- ein neuer, fertiggebildeter Cluster reiht sich hinten in die Clusterwarteschlange ein
- es gibt zwei Clusterwarteschlangen, jeweils eine auf der linken und rechten Seite des Transferweges
- der jeweils vordere Eintrag jeder Clusterwarteschlange wird verglichen, der Cluster mit der niedrigeren ID-Summe wird transferiert
Ist das ein halbwegs praktikabler und sinnvoller Ansatz? Und etwas konkreter: Wie koennte ich diese Cluster bilden? Also wie regele ich es, dass ein neuer Cluster erzeugt, passend von den umherschwirrenden Objekten befuellt, geschlossen und dann wieder ein neuer erzeugt wird?
Zum Befuellen wuerde ich ein MUTEX benutzen, sodass wirklich nur ein Objekt gerade auf den Cluster pruefen und sich hinzufuegen darf.
Fuer die Clusterwarteschlange wuerde ich mir eine verkettete Liste bauen, ist das sinnvoll oder schon zu kompliziert? Irgendwie hab ich das Gefuehl, dass das einfacher und eleganter sein muesste.
|
|
|
|
|
|
|
|
|
|
|
Ein paar Punkte sind mir noch nicht ganz klar:
Alle Objekte von Rechts sollen nach Links und umgekehrt?
Für wen muss es 'fair' sein? Objekttypen? Seiten?
Prinzipiell sehe ich 3 Prozesse/Threads: Pool A, Pool B und der Monitor für die Verbindung. Beide Pools werfen zufällig Objekte auf den Monitor und empfangen vom Monitor. Der Rest hängt von den offenen Punkten ab.
|
|
|
|
|
|
|
|
|
|
|
|
Ja, alle Objekte von rechts wollen/sollen nach links und vice versa. Fairness soll fuer die Objekte gegeben sein, so hab ichs jedenfalls verstanden. Sprich: Jedem Objekt, das die Verbindung passieren moechte, muss dies zur irgendeinem Zeitpunkt garantiert auch moeglich sein.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von MCignaz am 14.06.2013 15:32]
|
|
|
|
|
|
|
|
|
Danke für die Hinweise.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von con_chulio
| | Zitat von csde_rats
| | Zitat von B0rG*
Apropos: Gibt es irgendeine gescheite Möglichkeit C++-Template Code zu debuggen?
| |
Genauso wie normalen Code?!
| |
also ganz viele cout << "Hier bin ich" << endl;
*muhahahahaha*
| |
"Dies sollte nie angezeigt werden."
... und dann im Release vergessen. Business as usual!
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von NRG_Mash
| | Zitat von csde_rats
Jo Clang macht oft etwas besser verständliche Fehlermeldungen als GCC & wird auch in einigen IDEs genutzt. Der erzeugte Code ist allerdings schlechter als der vom GCC.
| |
Was heißt 'schlechter'? Ich habe bisher immer gcc benutzt und bin immer zufrienden gewesen. Ich hab nur mal gehört, dass clang schneller im compilen sei. Willst du dazu etwas schreiben? Würd mich mal echt interessieren, vorallem da ich auf die schnelle keinen interessanten Vergleich gcc va. clang gefunden habe.
| |
clang kompiliert schneller als gcc und macht bessere Fehlermeldungen, optimiert den Code aber schlechter als der GCC.
Bei Phoronix gibt's da nen paar Benchmarks zu, allerdings sind die Fazitten™ Bullshit.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von MCignaz
Folgende Aufgabe:
Drei Klassen verschieden großer Objekte (große, mittlere und kleine) duerfen sich nur nach folgender Regel von A nach B und umgekehrt bewegen: Der Weg zwischen A und B darf zur gleichen Zeit immer nur in einer Richtung benutzt werden; entweder von einem großen, von einem oder zwei mittleren, von einem mittleren und ein bis zwei kleinen oder von hoechstens vier kleinen Objekten.
Entwickeln Sie einen fairen (!) Algorithmus zur Synchronisation der Bewegungen vieler Objekte und begruenden Sie seine Korrektheit.
Dazu habe ich mir folgende Ueberlegungen gemacht:
- jedes Objekt bekommt eine ID, die einfach immer aufsteigend von 0 beginnend vergeben werden und eine Eigenschaft (links oder rechts) mit ihrer Herkunft
- ein Objekt (gross, mittel, klein) hat eine Zahl, die den Platzanspruch repraesentiert (4, 2, 1)
- die herumschwirrenden Objekte sollen sich zu "Clustern" zusammenfinden, also einer uebergeordneten Struktur, die "4" Platz bietet. Damit sollen die Objekte portioniert werden fuer den Transfer
- ein fertiger Cluster enthaelt eine Zahl, die die Summe der IDs der in ihm enthaltenen Objekte ist
- ein neuer, fertiggebildeter Cluster reiht sich hinten in die Clusterwarteschlange ein
- es gibt zwei Clusterwarteschlangen, jeweils eine auf der linken und rechten Seite des Transferweges
- der jeweils vordere Eintrag jeder Clusterwarteschlange wird verglichen, der Cluster mit der niedrigeren ID-Summe wird transferiert
Ist das ein halbwegs praktikabler und sinnvoller Ansatz? Und etwas konkreter: Wie koennte ich diese Cluster bilden? Also wie regele ich es, dass ein neuer Cluster erzeugt, passend von den umherschwirrenden Objekten befuellt, geschlossen und dann wieder ein neuer erzeugt wird?
Zum Befuellen wuerde ich ein MUTEX benutzen, sodass wirklich nur ein Objekt gerade auf den Cluster pruefen und sich hinzufuegen darf.
Fuer die Clusterwarteschlange wuerde ich mir eine verkettete Liste bauen, ist das sinnvoll oder schon zu kompliziert? Irgendwie hab ich das Gefuehl, dass das einfacher und eleganter sein muesste.
| |
Ohne viel Ahnung von Nichtsequentielle Programmierung zu haben: Mach es doch wie Ethernet. Die Objekte versuchen gleichzeitig rüber zu kommen. Falls die Strecke schon belegt ist -> zufälliger exponentieller backup. Jedes Objekt kommt nach endlicher Zeit mal drüben an.
(Die Aufgabenstellung sagt nichts von Optimierung  )
|
|
|
|
|
|
|
|
|
|
|
|
Naja meine Probleme sind da schon eine Stufe konkreter Richtung Implementierung. Dennoch danke!
|
|
|
|
|
|
|
|
|
|
|
Mal wieder ein einwurf zu nicht standardkonfomen code, der mit einem ordentlichen compiler fehler wirft wo man auch mit einer guten Fehlermeldung dumm davor steht. Ich zumindest kurz vor feierabend. 
| |
| Code: |
bool xxx::notInContainer(T2DOffsetROM* or) const {
// bla
}
|
|
|
|
|
|
|
|
|
|
|
|
|
Was soll das const an der Stelle überhaupt bewirken? 
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Schreibt man das nicht nur in die Deklaration, wie z.B. nen Standardwert auch? :O
/e: Tatsache!
| |
| Code: |
% cat t.c
int main(){
int and, or;
}
% clang++ t.c
clang: warning: treating 'c' input as 'c++' when in C++ mode, this behavior is deprecated
t.c:2:5: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
int and, or;
^
t.c:2:8: error: expected unqualified-id
int and, or;
^
1 warning and 1 error generated.
zsh: exit 1 clang++ t.c |
|
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von csde_rats am 14.06.2013 19:30]
|
|
|
|
|
|
|
|
|
Nein, mit overloading kann man zwei funktionen schreiben die gleich heißen, mit gleichen parametern, von denen eine const ist und die andere nicht. Meine ich mich zumindest zu erinnern.
Deswegen muss es auch in die implementierung.
Punkt für AcidF!re, MSVC unterstützt die and/or/... schlüsselworte nicht. 
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Admiral Bohm am 14.06.2013 19:33]
|
|
|
|
|
|
|
|
|
|
Ich schätze mal rats dachte man müsste das const nur bei der Definition angeben (also im Header) und könnte das in der Implementation selbst weglassen. Zumindest hab ich ihn so verstanden.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Deklaration ist das gesuchte Wort. :x
edit: an acid
edit2: Und Blohms Antwort darauf gibt doch eine passende Begruendung, warum es so ist.
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von PutzFrau am 14.06.2013 19:35]
|
|
|
|
|
|
|
|
|
|
Anfang Juli Projektantrag verteidigen...äh..."Vermarktungspotential darstellen". Ich bin gespannt.
|
|
|
|
|
|
|
|
| Thema: pOT-lnformatik, Mathematik, Physik XIII ( Completely Automated Public User Test To tell PIMP ) |
