Zeitmessung

enno-tyrant

wenn du die zeit behalten möchtest, dann übergib sie einer variable und lies sie nicht immer wieder aufs neue aus

Shade Of Mine

enno-tyrant schrieb:

wenn du die zeit behalten möchtest, dann übergib sie einer variable und lies sie nicht immer wieder aufs neue aus

Nö

leo aka qsch

ich frage mich oft warum solche Sachen nicht gepath werden oder
warum man es nicht vorher schon ordentlich macht (bzw testet)

Walli

Zu C-Zeiten hatte man sich scheinbar keine Gedanken darüber gemacht, dass man irgendwann Operatoren überladen kann und es für eine gute Lösung gehalten. Nachträglich rumpatchen ist auch Mist, weil dann bereits bestehender Code fehlerhaft wird.

Shade Of Mine

leo aka qsch schrieb:

ich frage mich oft warum solche Sachen nicht gepath werden oder
warum man es nicht vorher schon ordentlich macht (bzw testet)

Es ist by Design so.
ctime() ist sowieso blödsinnig, weil so nen Datumstring kann man sich leicht selber bauen und den bedürfnissen anpassen.

außerdem ist es bereits 'gepatcht' es gibt ctime_r() welches zu POSIX gehört

ctime() ist einfach dafür da, mal schnell ein Datum auszugeben, quasi eine RAD funktion

@MaSTaH:
nur doof, dass printf("%s%s", ctime(a), ctime(b));
das selbe Problem hat wie das cout hat

Walli

Shade Of Mine schrieb:

@MaSTaH:
nur doof, dass printf("%s%s", ctime(a), ctime(b));
das selbe Problem hat wie das cout hat

Wer macht denn auch so was ? Ausserdem gibts ja boost.date_time.

hehejo

Shade Of Mine schrieb:

Kommt dir jetzt die erleuchtung?
Wenn nein, dann überlege dir, wie genau der ablauf von
cout<<ctime(a)<<ctime(b);
aussieht.
was wird aufgerufen und in welcher reihenfolge.

Analog meinen Ausgaben:
Erst wird ctime(a) an cout gegeben und dann ctime(b).
Aber so ganz raff ich des dennoch nicht.

ness

Eine kleine Hilfe: die Funktion könnte so aussehen:

const char* const ctime(time_t& t)
{
    static char* result;
    //formatiere result anhand von t
    return result;
};

(Stimmt doch so in etwa, oder?)
/edit: ich bin doof

Shade Of Mine

hehejo schrieb:

Erst wird ctime(a) an cout gegeben und dann ctime(b).
Aber so ganz raff ich des dennoch nicht.

und ctime() liefert einen zeiger
und worauf zeigt dieser?

hehejo

Shade Of Mine schrieb:

hehejo schrieb:

Erst wird ctime(a) an cout gegeben und dann ctime(b).
Aber so ganz raff ich des dennoch nicht.

und ctime() liefert einen zeiger
und worauf zeigt dieser?

Dieser müsste dann auf static char result;* zeigen.

Nebenbei:
Das mit einer "static" Variablen in einer Funktion kenne ich nicht und weiß auch nicht, was das bewirkt.
//edit
Jetzt weiß ich das:
http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=static#Answ

Ovaron123

ist das vielleicht so gemeint?

time_t anfangszeit;
time_t zeit1,zeit2;

zeit1 = time(&anfangszeit);
_sleep(2000);
zeit2 = time(&anfangszeit);

Aber das funktioniert glaub ich bloß bis:
19:14:07, January 18, 2038

volkard

Ovaron123 schrieb:

Aber das funktioniert glaub ich bloß bis:
19:14:07, January 18, 2038

aus zuverlässigen quellen haben wir erfahren, daß mitte 2015 time_t auf 64 bit augeblasen wird. bis 2038 sollten alle rechner upgedated worden sein. wir haben nich nicht abschließend berechnen können, bis wann der 64-bitter langen wird. wie berechnet man das?

Ovaron123

Keine Ahnung, aber in MSDN steht:

After 23:59:59, December 31, 3000, UTC (using _time64 and __time64_t).

hehejo

Ovaron123 schrieb:

ist das vielleicht so gemeint?

time_t anfangszeit;
time_t zeit1,zeit2;

zeit1 = time(&anfangszeit);
_sleep(2000);
zeit2 = time(&anfangszeit);

Also eigentlich wollte ich ja nur ganz simpel den Zeitunterschied darstellen.

time_t start, end;
time(&start);
// ganz viele lange Sachen
time(&end);

// Gleichzeitige Ausgabe per ctime
cout << ctime(&start) << ctime(&end);

// Aber wie ich jetzt ja erfahren habe funktioniert das nicht wie gewünscht.
// Eher so
cout << ctime(&start); cout << ctime(&end);

volkard

ich habe noch keine begründung gesehen, warum das in einem ausgabebefehl nicht klappt. es scheinen zwar viele einen schimmer davon zu haben, aber es bleibt ein geheimnis und wird nubes nicht verraten.

Ovaron123

Ich weiß zwar nicht was er bei dir ausspuckt, aber bei mir ist ein Zeitunterschied von genau 2 Sekunden.

Aber wenn du Windows benutzen solltest, würde ich sowiso den Api-Befehl
"GetTickCount" benutzen.

hehejo

Ovaron123 schrieb:

Ich weiß zwar nicht was er bei dir ausspuckt, aber bei mir ist ein Zeitunterschied von genau 2 Sekunden.

Dieser Code

#include <iostream>
#include <ctime>

using namespace std;

int main()
{
  time_t start, end;
  time(&start);
  _sleep(2000);
  time(&end);

  // Gleichzeitige Ausgabe per ctime
  cout << ctime(&start) << ctime(&end);

  // Aber wie ich jetzt ja erfahren habe funktioniert das nicht wie gewünscht.
  // Eher so
  cout << ctime(&start); cout << ctime(&end);

  return 0;
}

gibt bei mir (in der Arbeit) diese Ausgabe

Wed Jan 05 09:40:51 2005
Wed Jan 05 09:40:51 2005
Wed Jan 05 09:40:51 2005
Wed Jan 05 09:40:53 2005

Ovaron123 schrieb:

Aber wenn du Windows benutzen solltest, würde ich sowiso den Api-Befehl "GetTickCount" benutzen.

Ja, hier in der Arbeit habe ich schon Windows - aber zuhause eben nicht.
Und darum versuche ich eben nichts spezifisches von Windows zu nehmen.

Shade Of Mine

hehejo schrieb:

Dieser müsste dann auf static char result;* zeigen.

Und was steht in result drinnen?

Nach dem ersten Aufruf steht was drinnen und was nach dem 2.?
Und was wird dann cout übergeben?

Denke nach: in welcher Reihenfolge werden diese 4(!) Funktionen aufgerufen

hehejo

Shade Of Mine schrieb:

hehejo schrieb:

Dieser müsste dann auf static char result;* zeigen.

Und was steht in result drinnen?

Nach dem ersten Aufruf steht was drinnen und was nach dem 2.?
Und was wird dann cout übergeben?

Nun, beim ersten Mal gibt es result noch nicht und darauf hin wird es als statische Funktionsvariable angelegt.
D.h. beim zweiten Aufruf von ctime steht genau das gleiche drin.

Wahrscheinlich prüft ctime ob es in result schon was stehen hat und wenn dann "rechnet/formatiert" ctime nimmer sondern gibt einfach das "Alte" aus.

Shade Of Mine schrieb:

Denke nach: in welcher Reihenfolge werden diese 4(!) Funktionen aufgerufen

4 Funktionen? Hab ich was verpasst?
Oder anscheinend das "<<"-Prinzip nicht ganz verstanden.

otze

hehejo schrieb:

Nun, beim ersten Mal gibt es result noch nicht und darauf hin wird es als statische Funktionsvariable angelegt.
D.h. beim zweiten Aufruf von ctime steht genau das gleiche drin.

Wahrscheinlich prüft ctime ob es in result schon was stehen hat und wenn dann "rechnet/formatiert" ctime nimmer sondern gibt einfach das "Alte" aus.

um genau zu sein, ist das keine statische variable, sondern eine globale variable, die von so ziemlicher jeder time funktion in <ctime> als puffer missbraucht wird.
die funktion dürfte auch herzlich wenig interessieren, ob da schon was drinsteht oder nicht,und da der puffer nie genullt wird, weis die funktion auch nicht wann der puffer ausgelesen wurde.

Shade Of Mine schrieb:

Denke nach: in welcher Reihenfolge werden diese 4(!) Funktionen aufgerufen

4 Funktionen? Hab ich was verpasst?
Oder anscheinend das "<<"-Prinzip nicht ganz verstanden.

es sind genau 4 funktionen, da jeder op<< eine eigene funktion darstellt.

@volkard mhh ich bin mir wirklich nicht sicher, was da los ist...

cout << ctime(&start)<< ctime(&end);

setzen wir mal klammern zur verdeutlichung:

(cout << ctime(&start))<< ctime(&end);

das forme ich mal so um, wies der compiler tut

//disclaimer: kein valides c++ mehr, nur visualisierung
operator <<(operator <<(cout,ctime(&start)),ctime(&end));

und wenn man diesen wust durchsieht, sieht man, dass der 2. op<< vor dem ersten aufgerufen wird.

nun hab ich leider mein drachenbuch nicht zur hand, aber soweit ich mich erinner,drehen die compiler die reihenfolge der parameter noch um,sodass quasi sowas am ende übrigbleibt:

//disclaimer: kein valides c++ mehr, nur visualisierung
operator <<(ctime(&end),operator <<(ctime(&start),cout));

daraus kann man erkennen, dass ctime(&end) vor ctime(&start) aufgerufen wird, und somit der rückgabewert von ctime(&end) verloren ist.

hier ein test der das beweist:

#include <iostream>
#include <ctime>

using namespace std;

//das muss in eine normale funktion, um sicherzustellen dass der aufruf nicht verschoben wird
char* test(char* in){
	cout<<in<<endl;
	return in;
}
int main()
{
  time_t start, end;
  time(&start);
  _sleep(2000);
  time(&end);

  // Gleichzeitige Ausgabe per ctime
  cout << ctime(&start)<< test(ctime(&end));

  int i;
  cin>>i;

  return 0;
}