c++.de :: Exceptionverwendung in größeren Projekten?

Mis2com Mitglied 16:56:00 27.04.2003 Titel:

suizid...

äh, ich meine, dann nehm ich lieber net weil vc6.0

Unregistrierter

quatsch. nimm exceptions

HumeSikkins Mitglied 17:07:00 27.04.2003 Titel:

Zitat:

äh, ich meine, dann nehm ich lieber net weil vc6.0

Falsche Schlussfolgerung. Ehrlich. Nimm eine Stoppuhr (einen Profiler) und miss es nach.

volkard Moderator 17:11:00 27.04.2003 Titel:

Zitat:

Original erstellt von Mis2com:
äh, ich meine, dann nehm ich lieber net weil vc6.0

nachdem du gemessen hast bitte. alles andere wäre unfug.
und auch dann nur, wenn der unterschied drastisch ist, denn du wirst ja bald auf nen moderneren compiler umsteigen müssen, und spätestens da gibts kein problem.

nur mal angenommen, ein funktionsaufruf sei dreimal so lang. mit alten mitteln müßtest du auf jeden fall den aufruf in ein if stecken und oft sogar nen zusätzlichen parameter für den fehlercode reinmachen und dann willste schneller sein?

(ach, warum geb ich mis2com eigentlich tips? ich stelle es ein.)

Mis2com Mitglied 17:39:00 27.04.2003 Titel:

ok, dann nehm ich exceptions

Gerard Mitglied 23:00:00 30.04.2003 Titel:

ich brauche mal ne idee wie ich das vernünftig vergleichen kann, das ist ein fight gegen den compilier und seine fähigkeiten sachen zu optimieren

was haltet ihr von diesen code für den anfang?

C++:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62	#include <iostream> #include <vector> #include <cstdlib> #include <stop_watch.h> using namespace std; vector<int> v( 10 ); int index = 0; void foo() { if(!(index % 100)) throw 1; } int foo_no_excp() { if(!(index % 100)) return 1; return 0; } int main() { #define TEST_EXCP 1 dim::time_measure tm( 100000 ); do { #if TEST_EXCP try { foo(); } catch(int) { v[index++ % 10]++; } #else if(foo_no_excp()) v[index++ % 10]++; #endif }while( tm ); cout << tm << endl;; copy( v.begin(), v.end(), std::ostream_iterator<int>( cout, " * ") ); cout << endl; return 0; }

hier ist der inhalt von stop_watch.h, hoffe nicht das es die ergebnise verfälscht

C++:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153	#ifndef STOPWATCH_H_DIM #define STOPWATCH_H_DIM #include <iostream> #include <string> #include <windows.h> namespace dim { typedef __int64 int64_t; class stop_watch { public: stop_watch() { reset(); } void reset() { Sleep( 0 ); starttime_ = ticks(); } int64_t time() const { return ticks() - starttime_; } private: int64_t ticks() const { #pragma warning(disable:4035) __asm rdtsc; #pragma warning(default:4035) } private: int64_t starttime_; }; class average { public: average(unsigned int n) : sum_( 0 ), count_( 0 ), n_( n ) { } bool need_more_values() const { return n_ != 0; } average & operator+= (stop_watch & sw) { sum_ += sw.time(); ++count_; if(n_) --n_; return this; } int64_t value() const { if(count_) return sum_ / count_; else return sum_; } private: int64_t sum_; unsigned int count_; unsigned int n_; }; class time_measure { public: time_measure(int n) : av_( n ) { } operator void () { av_ += sw_; sw_.reset(); if(av_.need_more_values() == 0) return NULL; else return (void*)1; } int64_t value() const { return av_.value(); } private: average av_; stop_watch sw_; }; std::string i64tostr(int64_t nr) { std::string res; do { res.insert( res.begin(), nr % 10 + '0' ); nr /= 10; }while(nr); return res; } std::ostream & operator<< (std::ostream & os, const time_measure & sw) { return os << i64tostr( sw.value() ); } std::ostream & operator<< (std::ostream & os, const stop_watch & sw) { return os << i64tostr( sw.time() ); } std::ostream & operator<< (std::ostream & os, const average & av) { return os << i64tostr( av.value() ); } }//end of namespace dim #endif

Gerard Mitglied 01:20:00 03.05.2003 Titel:

meine benchmarks stinken nach benchmark :(

hatt jemand code mit viel fehlerhändling usw. das sich für ein benchmark eignet (keine user abfragen usw.)

[ Dieser Beitrag wurde am 03.05.2003 um 01:28 Uhr von Dimah editiert. ]

volkard Moderator 01:27:00 03.05.2003 Titel:

Zitat:

Original erstellt von Dimah:
meine benchmarks stinken nach benchmark

jo.
laß exceptions nicht fliegen, um ein dateiende anzuzeigen, oder nen stack, der leer war. eher, um ne nicht existierende datei oder speichermangel anzuzeigen. und siehe da, die fliegt so sauselten, daß du keine guten chancen hast, die auszumessen.
teste also mal lieber

int f(){int r=rand();if(r==0) throw 1;return r;}//nebst catch

gegen

int f(int* err){int r=rand();if(r==0) *err=1;return r;}//nebst if