Zeitablauf speichern und ermitteln
-
Hallo,
habe mal eine Frage an euch. Ich will in einer dialogbasierenden Anwendung 2 Button Namens "Start" und "Stop" einfügen. Wenn auf den Startbutton geklickt wird, dann sollen sekunden von 0 angefangen heraufgezählt werden und wenn ich den Stopbutton klicke, soll die bis dahin vergangenge Zeit in einem Textfeld angezeigt werden. Wenn wieder auf Start und dann Stop geklickt wird soll die zeit zu der vorherigen zeit addiert werden, so dass eine neue, höhere zeit im Textfeld steht. Wie kann ich es machen...hat jemand einen Tipp??
Vielen Dank und frohe WEIHNACHT
-
Hallo,
ich denke, das es in etwa so aussehen sollte, aber ich komme nicht weiter, so dass wirklich sekunden gezählt werden...wäre nett, wenn einer helfen kann.
void CTimerDlg::OnStart()
{
UpdateData(TRUE);
SetTimer(1,1,NULL);
}void CTimerDlg::OnStop()
{
UpdateData(FALSE);
OnTimer(m_Timer);
}
-
Die Behandlung der Zeit ist ein wichtiges Thema, daher hier ein Ausschnitt aus einem Kapitel, das sich noch im Entwurf befindet (Bilder fehlen, da dies hier nur textorientiert ist). Ich hoffe, das hilft weiter:
Zeit
In diesem Kapitel werden wir untersuchen, über welche Möglichkeiten man in der Windows-Programmierung verfügt, das Thema "Zeit" zu be-han-deln. In der klassischen C/C++-Programmierung findet man für die genaue Bestimmung eines aktuellen Zeitpunktes vielleicht ein Programm wie das folgende:
#include <ctime> #include <cstdio> #include <cstring> #include <iostream> using namespace std; int main() { time_t long_time; time( &long_time ); struct tm *pt = localtime( &long_time ); int year = pt->tm_year + 1900; int month = pt->tm_mon + 1; int day = pt->tm_mday; int weekday = pt->tm_wday; int hour = pt->tm_hour; int minute = pt->tm_min; int sec = pt->tm_sec; char szmonth[4]; char szwday[11]; char szDatum[30]; char szUhrzeit[20]; switch( month ) { case 1: strcpy( szmonth,"JAN" ); break; case 2: strcpy( szmonth,"FEB" ); break; case 3: strcpy( szmonth,"MAR" ); break; case 4: strcpy( szmonth,"APR" ); break; case 5: strcpy( szmonth,"MAI" ); break; case 6: strcpy( szmonth,"JUN" ); break; case 7: strcpy( szmonth,"JUL" ); break; case 8: strcpy( szmonth,"AUG" ); break; case 9: strcpy( szmonth,"SEP" ); break; case 10: strcpy( szmonth,"OKT" ); break; case 11: strcpy( szmonth,"NOV" ); break; case 12: strcpy( szmonth,"DEZ" ); break; } switch( weekday ) { case 0: strcpy( szwday,"Sonntag" ); break; case 1: strcpy( szwday,"Montag" ); break; case 2: strcpy( szwday,"Dienstag" ); break; case 3: strcpy( szwday,"Mittwoch" ); break; case 4: strcpy( szwday,"Donnerstag" ); break; case 5: strcpy( szwday,"Freitag" ); break; case 6: strcpy( szwday,"Samstag" ); break; } sprintf( szDatum, "Datum: %s, %d. %s %d", szwday, day, szmonth, year ); sprintf( szUhrzeit, "Uhrzeit: %02d:%02d:%02d", hour, minute, sec ); cout << szDatum << "\n" << szUhrzeit << endl; return 0; }Der Programmteil, der sich mit dem Ermitteln und Interpretieren von Datum und Uhrzeit beschäftigt, steckt in diesen drei Zeilen:
time_t long_time;
time( &long_time );
struct tm *pt = localtime( &long_time );time_t speichert die Zeit in Form einer Variable vom Typ long int. Mit diesen 32 Bit kann man Datum und Uhrzeit im Zeitbereich von 1.1.1970 bis zum 18. Januar 2038 darstellen.
Die Funktion time(...) besitzt folgende Syntax
time_t time( time_t *Zeit_in_Sekunden )
und liefert die Systemzeit als Rückgabewert. Dieser Wert repräsentiert die Zeit als UTC (coordinated universal time) dargestellt seit dem 1.1.1970, 00:00 Uhr, in Se-kun-den. Wenn man als Parameter die Adresse einer Vari-ab--len vom Typ time_t übergibt, wird die Zeit in dieser Variable gespeichert . Wählt man als Parameter den NULL-Zeiger, so ent-fällt die Speicherung. Alternativ zu den obigen drei Zeilen könnte man daher alternativ auch diesen Code ver-wenden:
time_t long_time = time( NULL );
struct tm *pt = localtime( &long_time );Bei der Umrechnung auf übliche Werte von Kalenderdatum und Uhrzeit hilft uns die Funktion
struct tm * localtime( const time_t *Zeit_in_Sekunden );
Die Funktion localtime(...) übernimmt die Zeit im Format time_t und liefert einen Zeiger auf eine Struktur vom Typ tm zurück. Diese Struktur besitzt folgende Komponenten vom Typ int:
tm_sec Sekunden
tm_min Minuten
tm_hour Stunden
tm_mday Tag des Monats (1 – 31)
tm_mon Monat (0 – 11; Januar = 0)
tm_year Jahr (Laufendes Jahr minus 1900)
tm_wday Wochentag (0 – 6; Sonntag = 0)
tm_yday Tag des Jahres (0 – 365; 1. Januar = 0)
tm_isdst Status der "Daylight Saving Time" (DST) nach US-Regeln:
DST aktiv: positiver Wert
DST nicht aktiv: 0
unklar: negativer WertBeachten Sie, dass bei der Struktur tm die Zählweise bei Monat, Jahrestag und Wochentag bei 0 und nicht bei 1 beginnt. Dass man beim Jahr noch die Zahl 1900 addieren muss, ist auch nicht gerade kundenfreundlich.
CTime
Auf der Grundlage des Datentyps time_h wurde die MFC-Klasse CTime entwickelt, die wie CString und die anderen Simple Value Typen nicht von der MFC-Basisklasse CObject abgeleitet ist. Sie finden diese Klasse in den MFC-Dateien afx.h und timecore.cpp. Nachfolgend realisieren wir das obige Programmbeispiel mit dieser MFC-Klasse. Wir verwenden der Einfachheit halber Konsolenanwendungen (vergessen Sie nicht, in den Compilereinstellungen die MFC einzubinden):
#include <afx.h> #include <iostream> using namespace std; int main() { CTime ct = CTime::GetCurrentTime(); int year = ct.GetYear(); int month = ct.GetMonth(); int day = ct.GetDay(); int weekday = ct.GetDayOfWeek(); int hour = ct.GetHour(); int minute = ct.GetMinute(); int sec = ct.GetSecond(); CString strMonth; CString strWday; CString strDate; CString strTime; switch( month ) { case 1: strMonth = "JAN"; break; case 2: strMonth = "FEB"; break; case 3: strMonth = "MAR"; break; case 4: strMonth = "APR"; break; case 5: strMonth = "MAI"; break; case 6: strMonth = "JUN"; break; case 7: strMonth = "JUL"; break; case 8: strMonth = "AUG"; break; case 9: strMonth = "SEP"; break; case 10: strMonth = "OKT"; break; case 11: strMonth = "NOV"; break; case 12: strMonth = "DEZ"; break; } switch( weekday ) { case 1: strWday = "Sonntag"; break; case 2: strWday = "Montag"; break; case 3: strWday = "Dienstag"; break; case 4: strWday = "Mittwoch"; break; case 5: strWday = "Donnerstag"; break; case 6: strWday = "Freitag"; break; case 7: strWday = "Samstag"; break; } strDate.Format( "Datum: %s, %d. %s %d", strWday, day, strMonth, year ); strTime.Format( "Uhrzeit: %02d:%02d:%02d", hour, minute, sec ); cout << LPCTSTR(strDate) << "\n" << LPCTSTR(strTime) << endl; return 0; }Sie sehen, dass man die Formatanweisungen der Funktion printf(...) aus der Programmiersprache C in der Funk-tion CString::Format(...) wieder findet. Bei CTime beginnt die Zählweise für Wochentage und Monate bei 1 und nicht bei 0. Auf diesen Unterschied sollte man ach-ten. Die aktuelle Uhrzeit ermittelt man bequem mit der statischen Funktion CTime::GetCurrentTime():
CTime ct = CTime::GetCurrentTime();
Ansonsten setzt man Get...-Funktionen ein, um die Details von Datum und Uhrzeit zu gewinnen. Dies erfolgt im Prinzip analog zu der Vorgehensweise mit der Struktur tm, hier bei dieser MFC-Klasse jedoch objektorientiert mit Member-Funk-tionen. Folgende Get-Funktionen zur Gewinnung einzelner Elemente (Extraktion) stehen zur Verfügung:
int CTime::GetYear() const;
int CTime::GetMonth() const;
int CTime::GetDay() const;
int CTime::GetDayOfWeek() const;
int CTime::GetHour() const;
int CTime::GetMinute() const;
int CTime::GetSecond() const;
int CTime::GetTime() const;Betrachtet man die bisher vorgestellten Typen time_t, tm und CTime, so kann man wie folgt Umwandlungen ineinander durchführen:
tm ergibt CTime: CTime::CTime( mktime( tm ) );
time_t ergibt CTime: CTime::CTime( time_t time );
CTime ergibt tm: struct tm* CTime::GetLocalTm( struct tm* ptm = NULL ) const;
struct tm* CTime::GetGmtTm( struct tm* ptm = NULL ) const;
CTime ergibt time_t: time_t CTime::GetTime( ) const;CTime besitzt eigene Format-Funktionen, die den Typ CString zurückliefern, sodass man die Datum- und Zeitausgabe sehr kompakt schreiben kann:
#include <afx.h> #include <iostream> using namespace std; int main() { CTime ct = CTime::GetCurrentTime(); cout << LPCTSTR( ct.Format( "%A, %B %d, %Y %H:%M:%S" ) ) << endl; cout << LPCTSTR( ct.FormatGmt( "%A, %B %d, %Y %H:%M:%S" ) ) << endl; return 0; }CTime::Format(...) liefert die lokale Zeit, während CTime::FormatGmt(...) die Zeit als UTC angibt.
Will man allgemein ein Objekt der Klasse CTime erzeugen, ohne die aktuelle Uhrzeit abzufragen, so hat man die Mög-lichkeit, Datum und Uhrzeit als Parameter anzugeben. Folgende Konstruktoren stehen zur Verfügung:
CTime( );
CTime( const CTime& timeSrc );
CTime( time_t time );
CTime( WORD wDosDate, WORD wDosTime, int nDST = -1 );
CTime( const SYSTEMTIME& sysTime, int nDST = -1 );
CTime( const FILETIME& fileTime, int nDST = -1 );
CTime( int nYear,
int nMonth,
int nDay,
int nHour,
int nMin,
int nSec,
int nDST = -1 );Falls wir ein Datum und eine Uhrzeit als CTime-Objekt darstellen wollen, so nehmen wir einfach den letzten Konstruktor. So können wir z.B. den 02.Januar 2002, 11.15 Uhr auf folgende Weise in der Parameterliste übergeben:
CTime t( 2002, 1, 2, 11, 15, 0 ); // 02.01.2002, 11:15 h
Bezüglich der anderen Konstruktoren wollen wir noch die Win32-Strukturen SYSTEMTIME und FILETIME unter-suchen.
SYSTEMTIME ist wie folgt definiert:typedef struct _SYSTEMTIME {
WORD wYear;
WORD wMonth; // Januar ist 1
WORD wDayOfWeek; // Sonntag ist 0
WORD wDay;
WORD wHour;
WORD wMinute;
WORD wSecond;
WORD wMilliseconds;
} SYSTEMTIME;SYSTEMTIME interpretiert Datum und Uhrzeit unter Verwendung der oben dargestellten Komponenten vom 16-Bit-Typ WORD, deren Namen selbsterklärend sind.
Wollen Sie diese Win32-Struktur SYSTEMTIME aus CTime gewinnen, verwenden Sie folgende Member-Funktion der Klasse CTime:
BOOL CTime::GetAsSystemTime ( SYSTEMTIME& timeDest ) const;
Völlig anders ist die Struktur FILETIME aufgebaut. Hier werden 100-Nanosekunden-Zeitabschnitte gezählt:
typedef struct _FILETIME {
DWORD dwLowDateTime; /* niederwertiges DWORD /
DWORD dwHighDateTime; / hoeherwertiges DWORD */
} FILETIME, *PFILETIME, *LPFILETIME;Diese Struktur stellt eine zusammengesetzte 64-bit-Ganzzahl dar. Damit kann man die Anzahl der 100-Nanosekunden-Intervalle seit dem 01.01.1601 darstellen ( 1 Nanosekunde = 10-9 Sekunden ).
Sie sehen, dass die Windows-Programmierung hier wieder einmal eine ganze Menge historischen Ballast mit sich schleppt.
Selbst ein Konstruktor zur Übernahme von Datum und Uhrzeit im 16-Bit-MS-DOS-Format steht noch zur Verfügung.
CTime( WORD wDosDate, WORD wDosTime, int nDST = -1 );
Das MS-DOS-Datum wDosDate hat folgenden Aufbau:
Bits Bedeutung
0 – 4 Tag des Monats (1–31)
5 – 8 Monat (1 = Januar)
9 – 15 Jahr (man muss 1980 zum aktuellen Wert addieren).Die MS-DOS-Zeit wDosTime ist wie folgt aufgebaut:
Bits Bedeutung
0 – 4 Sekunden geteilt durch 2
5 – 10 Minute (0–59)
11 – 15 Stunden (0– 23)Wie Sie sehen, ist die Verwendung Klasse CTime insgesamt recht unkompliziert. Sie setzt intern allerdings die strftime-Funktion ein. Dies führt dazu, dass die CTime-Klasse nicht innerhalb einer DLL ein--ge-setzt werden kann. Darauf müssen Sie achten.
CTimeSpan
Die MFC-Klasse CTimeSpan repräsentiert eine Zeitspanne. Dies kann zum Beispiel die Differenz zweier Objekte vom Typ CTime sein. Nachfolgend sehen Sie ein kleines Codebeispiel:
CTime t1 = CTime::GetCurrentTime();
// ... Diese Aktion findet zwischen t1 und t2 statt.
CTime t2 = CTime::GetCurrentTime();
CTimeSpan dt = t2 - t1;Man kann ein Objekt vom Typ CTimeSpan auch im Konstruktor mit Daten füttern. Folgende Konstruktoren stehen zur Verfügung:
CTimeSpan( );
CTimeSpan( const CTimeSpan& timeSpanSrc );
CTimeSpan( time_t time );
CTimeSpan( LONG lDays, int nHours, int nMins, int nSecs );
Die Klasse CTimeSpan stellt analog zu CTime Member-Funktionen zur Verfügung, um die Werte der Komponenten der Zeitspanne abzufragen.
LONG CTimeSpan::GetDays ( ) const;
int CTimeSpan::GetHours( ) const; // -23 bis +23
LONG CTimeSpan::GetTotalHours( ) const;
int CTimeSpan::GetMinutes( ) const; // -59 bis +59
LONG CTimeSpan::GetTotalMinutes( ) const;
int CTimeSpan::GetSeconds( ) const; // -59 bis +59
LONG CTimeSpan::GetTotalSeconds( ) const;Wir verwenden ein kleines Konsolenprogramm, um diese Funktionen in Aktion zu sehen:
#include <afx.h> #include <iostream> using namespace std; int main() { CTime ct = CTime::GetCurrentTime(); CTimeSpan ts, one_hour( 0, 1, 0, 0 ); int d , m, y, h; y = 0; h = 0; while ( y < 1970 || y > 2037 || m < 1 || m >12 || d < 1 || d > 31 ) { cout << "Bitte geben Sie Ihr Geburtsdatum (nach dem 1.1.1970) ein\n" << "( Format: Tag Monat Jahr): "; cin >> d >> m >> y; if ( ( y==1970 ) && ( m==1 ) && ( d==1 ) ) h = 1; } CTime tBirthdate( y, m, d, h, 0, 0 ); ts = ct - tBirthdate; if ( (y==1970)&&(m==1)&&(d==1) ) ts = ts + one_hour; cout << "\nAktuelle Zeit: " << LPCTSTR( ct.Format( "%A, %B %d, %Y %H:%M:%S" ) ) << endl; cout << "\nSeit Mitternacht Ihres Geburtstages sind " << "folgende Zeiten vergangen:\n" << endl; cout << "Tage: " << ts.GetDays() << " oder \n" << "Stunden: " << ts.GetTotalHours() << " oder \n" << "Minuten: " << ts.GetTotalMinutes() << " oder \n" << "Sekunden: " << ts.GetTotalSeconds() << endl; cout << "\nTage: " << ts.GetDays() << " " << "Stunden: " << ts.GetHours() << " " << "Minuten: " << ts.GetMinutes() << " " << "Sekunden: " << ts.GetSeconds() << "\n" << endl; return 0; }Das nachfolgende Beispiel zeigt die Zeitspanne zwischen 01.01.1970, 00:00:00 und 01.01.1980, 00:00:02 (1972 und 1976 waren Schaltjahre):
Dass Zeitspannen auch negativ sein können, zeigt folgendes Beispiel:
Falls Sie sich über die -12 Stunden wundern, obwohl es in dem Beispiel doch schon nach 12 Uhr ist, dann den-ken Sie bitte an die Sommer-/Winterzeit-Umstellung. Am Sonntag, 27.10.2002, wurde die Uhrzeit in Deutsch-land von Som-mer-- auf Winter-zeit umgestellt. Das bedeutet eine zusätzliche Stunde. Probieren wir es aus mit einem Datum zwei Tage später:
Dieses Beispiel kann man wieder einfacher nachvollziehen. Man findet, wie innerhalb der Winterzeit erwartet,
-11 Stunden. Also achten Sie auf diese Feinheiten. CTime und CTimeSpan beachten die Zeit-um-stel-lung. Das ist auch gut so.Sie sehen, diese einfachen Klassen der MFC kann man durch Einbinden von afx.h in Konsolenanwendungen verwenden. Ge-dacht sind diese aber eher im Zusammenspiel mit anderen MFC-Klassen und in typischen MFC-Architek-turen. Übertragen Sie unser kleinesBeispiel zur Übung doch einmal in eine Dialoganwendung.
COleDateTime und COleDateTimeSpanCOleDateTime bietet wie CTime, die Möglichkeit, Datum und Uhrzeit darzustellen. COleDateTimeSpan stellt wie CTimeSpan eine Zeitsspanne, z.B. die Differenz zwischen zwei COleDateTime-Objekten dar.
Warum gibt es diese Klassen eigentlich? Reichen CTime und CTimeSpan nicht aus? COleDateTime und COleDateTimeSpan sind insbesondere für die MFC-Datenbankprogrammierung vorgesehen und sollen bei der Auto-ma-tisierung mit der Klasse COleVariant zusammen-arbeiten. Also werfen wir einen kurzen Blick auf diese Klassen.
COleDateTime übertrifft CTime bezüglich Auflösung und Wertebereich. Der Zeitbereich vom 01.01.100 bis zum 31.12. 9999 wird problemlos durch ein COleDateTime-Objekt dargestellt. COleDateTime-Objekte besitzen eine Auf-lösung von ca. 1 Millisekunde. Das übertrifft CTime bei weitem. Denken Sie nur an unser kleines Lebens-zeit-Pro-gramm mit CTime und CTimeSpan. Da durften Sie nicht vor dem 1.1.1970 geboren sein. Wo gibt es denn sowas? Schauen wir uns also an, ob wir diese beiden - bedingt durch time_t als Basis - "engherzigen" Klas-sen einfach durch diese "OLE"-Klassen austauschen können.
COleDateTime verwendet den Datentyp DATE als Grundlage. Der Typ DATE ist eine 8-Byte-Gleitkommazahl. Der ganzzahlige Anteil steht für die Zahl der Tage seit dem 30.12.1899, während der Nachkommaanteil für die Uhrzeit bezogen auf 24 Stunden steht. Der Nachkommawert Null steht folglich für Mitter-nacht, Nachkommawert 0,5 bedeutet 12.00 h mittags. Der Ausgangspunkt 30.12.1899, 00:00 Uhr wird durch 0,000 dargestellt, ist also der Nullpunkt des Zeitstrahls. Der Zeitpunkt 01.01.1900, 0:00 Uhr, also zwei Tage später, entspricht dann dem Wert 2,000. Der Zeitpunkt 01.01.1900, 12:00 Uhr entspricht 2,500 und 04.01.1900, 21:00 Uhr folglich 5,875. Das ist soweit klar.
In MSDN wird auf "Unregel-mäßigkeiten" für die Tage vor dem 30. Dezember 1899 hingewiesen, die durch negative Zahlen dargestellt werden. Man findet dort folgende Beispiele.
Datum und Uhrzeit Zahl
30. Dezember 1899, 00:00 0,000
18. Dezember 1899, 00:00 -12,000
18. Dezember 1899, 06:00 -12,250
18. Dezember 1899, 12:00 -12,500
18. Dezember 1899, 18:00 -12,750Aha, wir können dem Typ COleDateTime von der Logik her also nicht vollständig trauen. Die Sym-metrie be-züg-lich des Null-punktes ist ebenfalls merkwürdig. Mit positiven Zahlen können wir Werte bis ins Jahr 9999 ab-bilden, während im negativen Bereich im Jahr 100 Schluß ist. Alles wenig vertrauenswürdig. Da müssen wir doch noch genauer hinschauen.
Damit wir Versuche durchführen können, benötigen wie ein kleines Programm:
#include <afxdisp.h> #include <iostream> using namespace std; int main() { COleDateTime odt; cout << "Gleitkommazahl eingeben: "; cin >> odt.m_dt; cout << "Eingegebener Zeitpunkt: " << LPCTSTR( odt.Format( "%A, %B %d, %Y %H:%M:%S" ) ) << endl; return 0; }Wir erstellen ein Objekt der Klasse COleDateTime und geben eine Gleitkommazahl ein, die wir direkt dem er-staun--li-cher-weise öffentlich zugänglichen Attribut m_dt (dt steht für DATE) zuweisen können. Die Format-Mem-ber-Funktion funktioniert analog der von CTime. Folgende Ergebnisse aus Versuchen seien hier dargestellt:
Eingegebene Gleitkommazahl Datum und Uhrzeit
-655500,75 19.04.0105, 18:00
-650000,20 10.05.0120, 04:48
-650000,75 10.05.0120, 18:00
-600000,10 02.04.0257, 02:24
-500000,25 16.01.0531, 06:00
-100000,25 16.03.1626, 06:00
-100000,75 16.03.1626, 18:00
-1,0001 29.12.1899, 00:00:09
-0,0001 30.12.1899, 00:00:09
0,0001 30.12.1899, 00:00:09
1,0001 31.12.1899, 00:00:09
20000,75 03.10.1954, 18:00
30000,25 18.02.1982, 06:00
40000,50 06.07.2009, 12:00
1000000,10 26.11.4637, 02:24
2955000,99 06.07.9990, 23:45:36Sie sehen, die Nachkommastelle entspricht immer auf gleiche Weise der Uhrzeit, egal ob man sich im negativen oder positiven Bereich befindet.
Die Konstruktoren von COleDateTime sind etwas variantenreicher als bei CTime:
COleDateTime( );
COleDateTime( const COleDateTime& dateSrc );
COleDateTime( time_t timeSrc );
COleDateTime( const SYSTEMTIME& systimeSrc );
COleDateTime( const FILETIME& filetimeSrc );
COleDateTime( int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec );
COleDateTime( WORD wDosDate, WORD wDosTime );
COleDateTime( const VARIANT& varSrc );
COleDateTime( DATE dtSrc );
Man kann ein Objekt vom Typ COleDateTime auch aus dem Typ VARIANT oder DATE erzeugen. Ansonsten wird die Sommerzeit von COleDateTime ignoriert. Darauf muss man achten, wenn man Zeitspannen berechnet.
Alternativ zu den Konstruktoren kann man mittels folgender Member-Funktion Datum und Zeit einstellen:
int COleDateTime::SetDateTime(
int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec );int COleDateTime::SetDate( int nYear, int nMonth, int nDay );
int COleDateTime::SetTime( int nHour, int nMin, int nSec );
Für die Extraktion vorhandener Daten gibt es die gleichen Funktionen wie bei CTime.
Analoges gilt für die Klasse COleDateTimeSpan. Hier gibt es folgende Konstruktoren:
COleDateTimeSpan( );
COleDateTimeSpan( const COleDateTimeSpan& dateSpanSrc );
COleDateTimeSpan( double dblSpanSrc );
COleDateTimeSpan( long lDays, int nHours, int nMins, int nSecs );
Wir setzen unser kleines Programm zur Abfrage der Lebenszeit nun auf diese Klassen um, so dass nun auch Geburtstage vor 1970 eingegeben werden können:
#include <afxdisp.h> #include <iostream> using namespace std; int main() { COleDateTime ct = COleDateTime::GetCurrentTime(); int d , m, y; while ( y < 100 || y > 9999 || m < 1 || m >12 || d < 1 || d > 31 ) { cout << "Bitte geben Sie Ihr Geburtsdatum (ab dem 1.1.100) ein\n" << "( Format: Tag Monat Jahr): "; cin >> d >> m >> y; } COleDateTime tBirthdate( y, m, d, 0, 0, 0 ); COleDateTimeSpan ts = ct - tBirthdate; cout << "\nAktuelle Zeit: " << LPCTSTR( ct.Format( "%A, %B %d, %Y %H:%M:%S" ) ) << endl; cout << "\nSeit Mitternacht Ihres Geburtstages sind " << "folgende Zeiten vergangen:\n" << endl; cout << "Tage: " << ts.GetDays() << " oder \n" << "Stunden: " << ts.GetTotalHours() << " oder \n" << "Minuten: " << ts.GetTotalMinutes() << " oder \n" << "Sekunden: " << ts.GetTotalSeconds() << endl; cout << "\nTage: " << ts.GetDays() << " " << "Stunden: " << ts.GetHours() << " " << "Minuten: " << ts.GetMinutes() << " " << "Sekunden: " << ts.GetSeconds() << "\n" << endl; return 0; }Das Programm ist einfacher geworden. Aber die Umstellung von Sommerzeit auf Winterzeit und umgekehrt wird schlichtweg ignoriert. Hier folgt ein Beispiel:
Das sieht auf den ersten Blick korrekt aus. Da aber am Morgen des 27.10.2002 um 02:00 h von Sommerzeit auf Winterzeit umgestellt wurde, wäre die korrekte Zeitspanne ein Tag, 4 Stunden, 7 Minuten und 5 Sekunden. Die zusätzliche Stunde fehlt bei COleDateTime. Da ist CTime im Vorteil.