Was ist time_t für ein Datentyp?

[Nite]

Nabend,

Ich programmiere gerade so zum Test ein kleines Programm, welches auch einen Timer enthalten soll. Also habe ich im Internet und auch in meinem C++ Buch nachgeschaut, aber überall wird immer die Funktion time() im Zusammenhang mit dem Datentyp time_t verwendet. Was genau ist so anders? Was speichert dieser Wert?
Ich konnte zu dieser Frage weder im Buch, noch im Web was finden...

Dann habe ich noch die Frage, ob time() einen timestamp zurückliefert?

Danke

[thordk]

time_t ist in time.h definiert. ist sehr wahrscheinlich nen long. und time() liefert die sekunden seit dem 1.1.1970, standard unix timestamp.

[Nite]

Okay, ich habe mal ein wenig getestet und einen Zeitstempel wiedergeben können:

#include <iostream>
#include <ctime>
using namespace std;

int main() {
    time_t timestamp;
    int atime = time(&timestamp);
    cout << atime << endl;
    return 0;
}

Nur leider verstehe ich nicht, wieso in auf Seiten wie cppreference.com geschrieben wird:

#include <time.h>
  time_t time( time_t *time );

und wenn man es anwenden möchte, funktioniert's nicht?!

int main() {
    int atime = time(time_t *timestamp);
    cout << atime << endl;
    return 0;
}

und gibt nur

time.cpp: In function int main()': time.cpp:7: error: cannot convert \time_t**' to `time_t*' for argument `1' to `time_t time(time_t*)'

wieder...

Also Frage 2 aus meinem ersten Beitrag wäre damit beantwortet. Nun bleibt nur die Frage, was ist time_t für ein Datentyp, was genau ist an dem so anders, im Gegensatz zu den anderen, und wieso funktioniert nicht die kurze Schreibweise?

Danke

[*D*Evil]

<a href= schrieb:

cppreference.com">If the argument 'time' is given, then the current time is stored in 'time'.

=>

#include <iostream>
#include <ctime>

int main() 
{
    std::time_t cur_time;
    std::time(&cur_time);
    std::cout << cur_time << std::endl;
}

<a href= schrieb:

cppreference.com">The function time() returns the current time, or -1 if there is an error.

=>

#include <iostream>
#include <ctime>

int main() 
{
    std::time_t cur_time = std::time(NULL);
    std::cout << cur_time << std::endl;
    // oder: std::cout << std::time(NULL) << std::endl
}

Noch Fragen?

[Nite]

Ah, jetzt hab ich's verstanden. Ich sollte beim nächsten mal wohl genauer lesen. ^^
Danke

Dann beschäftigt mich aber noch etwas: Ich schreibe gerade ein Programm, wo man einen Timer von Sekunden festlegen kann, und nach der Anzahl der Sekunden, wenn keine Eingabe erfolgte, soll keine Eingabe mehr möglich sein, und eine Meldung, dass die Zeit vorüber sei, ausgeben.

Ich habe die Theorie, dass man einfach eine while-Schleife machen könnte, die einmal abfragt, ob noch nicht eingegeben wurde und ob die Zeit schon vorbei ist:
(tanswer enthält die Antwort der Rechnung,
timelimit enhält das gewählte Zeitlimit,
atime enthält die aktuelle Zeit (also timestamp),
otime enhält die vor der rechnung gesetzte Zeit)

while(!cin >> tanswer || atime <= otime+timelimit) {}

Nur irgendwas stimmt da nicht, nur was?!
Danke

[*D*Evil]

std::time_t time_dest = std::time(NULL) + timelimit;
while (!std::getline(std::cin, calc_answer) && std::time(NULL) <= time);

sollte eigentlich sogar gehen ... lastet den CPU aber zu 100% aus ... nach TaskManager ... sollte zumindest

achja .. das heißt und ... da er ja aufhören soll, wenn eine richtige Eingabe erfolgt ...

[Nite]

Oh, na das soll ja nicht. Ich möchte ja nur für meine kleine Schwester (6, fast 7 Jahre) ein kleines Programm schreiben, mit dem sie ihre Mathekenntnisse verbessern kann und nicht ein Programm was sie innen Wahnsinn treibt, weil der PC ständig verreckt.

Wie könnte man das sonst lösen? Ich habe schon daran gedacht, dass das Programm auf eine Eingabe wartet, und wenn die Eingabe über dem Zeitlimit hinausgeht, dann wird die Meldung gemacht, dass man nicht schnell genug war. ^^ Gibt es denn nicht noch eine andere Lösung?

Danke
______________________________________

Ja, aber wenn man && anstatt || verwendet, dann wird doch, auch wenn man die Eingabe getan hat, der Countdown abgewartet, oder?

[*D*Evil]

Hmm probier es einfach aus ... sollte auch so gehen!
Sonnst Sleep(100) [Windows] usleep(100) [UNIX]

[Nite]

Sleep? Funktioniert nicht... Habe gegoogled und auch einiges gefunden. Ich habe es versucht, wie hier geschrieben: http://www.informatikboard.ch/programmiersprachen-allgemein/10473-c-sleep.html

#include <iostream>

int main() {
    sleep(500);
    std::cout << "5 Sekunden später" << std::endl;
    return 0;
}

Die Meldung des Kompilers ist:

sleep.cpp: In function int main()': sleep.cpp:4: error:sleep' undeclared (first use this function)
sleep.cpp:4: error: (Each undeclared identifier is reported only once for each function it appears in.)

So, nun gehe ich erstmal schlafen. Gut' Nacht und vielen Dank.

[*D*Evil]

hab ja extra Windows dahinter geschrieben ...

#include <windows.h>
#include <ctime>

int main()
{
    std::cout << std::time(NULL) << std::endl;
    ::Sleep(500);
    std::cout << "5s später!" << std::endl;
}

...

[morgen]

was ist mit _sleep()?
geht das nicht für beides,windows und linux?

[asjdhasdjahs]

Funktionen die mit _ beginnen sind generell Compilerspezifisch...

[Nite]

Okay, ich hatte es auch schon mit der include von windows.h versucht, nur ich hatte ganz oben am Kopf using namespace std; verwendet, was soweit ich weiß, nicht auf C-Bibliotheken (windows**.h**) zutrifft. Nun habe ich anstatt das zu schreiben, einfach std::cout verwendet. Du hast direkt ::Sleep(500) geschrieben, ist das etwa ein Verweis, auf _kein_ Namensbereich?
Habe dein Programm mal kompiliert, unter Windows mit g++ (MinGW). Leider ist's gerade mal 1 Sekunde die "geschlafen" wird. Was stimmt da nicht?!

Linux habe ich nicht, sondern FreeBSD, leider ist mein 2. Rechner gerade etwas kaputt, sodass ich nicht auf mein FBSD zugreifen kann.
____________________________________________________________

Nun aber mal zu meinem Programm. Ich habe es weitergeschrieben und habe es erstmal so gestaltet, dass man sich Zeit lassen kann, und sollte die Zeit vorbei sein, dann wird man nach der Eingabe darauf hingewiesen. Ich habe aber leider ein Problem mit einer If-Abfrage. Ich bekomme beim Kompilieren folgende Meldungen:

1mal1.cpp: In function int main()': 1mal1.cpp:23: warning: NULL used in arithmetic 1mal1.cpp:62: error: no match for 'operator||' in '(std::operator== [with \_CharT = char, \_Traits = std::char\_traits<char>, \_Alloc = std::allocator<char>](((const std::basic\_string<char, std::char\_traits<char>, std::allocator<char> >&)((const std::basic\_string<char, std::char\_traits<char>, std::allocator<char> >*)(&option))), ((const char*)"N")) || std::operator== [with \_CharT = char, \_Traits = std::char\_traits<char>, \_Alloc = std::allocator<char>](((const std::basic\_string<char, std::char\_traits<char>, std::allocator<char> >&)((const std::basic\_string<char, std::char\_traits<char>, std::allocator<char> >*)(&option))), ((const char*)"n"))) || (&option)->std::basic\_string<\_CharT, \_Traits, \_Alloc>::operator= [with \_CharT = char, \_Traits = std::char\_traits<char>, \_Alloc = std::allocator<char>](((const char*)"Nein"))' 1mal1.cpp:62: note: candidates are: operator||(bool, bool) <built-in> 1mal1.cpp:62: error:elseif' undeclared (first use this function)
1mal1.cpp:62: error: (Each undeclared identifier is reported only once for each function it appears in.)
1mal1.cpp:62: error: expected ;' before "endprog" 1mal1.cpp:63: error: expected primary-expression before "else" 1mal1.cpp:63: error: expected;' before "else"

Auf Zeile 62 ist eine If-Abfrage mit dem Or-Operator (||). Weiter oben habe ich es so aber auch benutzt, und er meckert nicht. Ich habe auch schon Klammern um die einzelnen Abfragen gemacht, was dem Compiler aber nicht weiter interessiert hat. Also im Buch geblättert und habe gesehen, dass die C-Lib iso646.h Synonyme für OR-Operator enthält. Also ciso646 Lib eingebunden und es hat sich nichts verändert... Ich bin wirklich ratlos, ich hoffe ihr könnt mir helfen. Hier der Quellcode (ps: Ich stelle den Quellcode hiermit unter der GPL ):

// started at 21st June 2007
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <ciso646>
#include <string>
#define PROGVER 0.1
#define MAXTIMELIMIT 60
using namespace std;

int main() {
    unsigned int timelimit, oldtime, atrue = 0, afalse = 0, excount = 0;
    unsigned short task1, task2, result, tanswer;
    bool endprog = false;
    string temp, option;

    cout << "Herzlich Willkommen zum 1mal1 Ubungsprogramm" << endl;
    cout << "mit Zeitlimit - Version" << PROGVER << endl << endl;
    L_timelimit:
        cout << "Bitte wahle ein Zeitlimit (in Sekunden):";
        cin >> timelimit;
    if(timelimit > MAXTIMELIMIT || timelimit < 1 || timelimit == NULL) {
        cout << "Dein Zeitlimit ist ungultig." << endl;
        cout << "Bitte wahle ein Zeitlimit zwischen 1 und " << MAXTIMELIMIT << "." << endl;
        goto L_timelimit;
    }

    cout << "Du hast als Zeitlimit" << timelimit << " Sekunden gewahlt." << endl;
    cout << "Drucke [ENTER] um fortzufahren." << endl;
    cin >> temp;

    while(endprog = false) {
        task1 = rand() % 10 + 1;
        task2 = rand() % 10 + 1;
        result = task1 * task2;
        oldtime = time(NULL);
        excount++;

	cout << "Aufgabe " << excount << ":" << endl << endl;
        cout << "Wie viel ist " << task1 << "*" << task2 << "?" << endl;
        cin >> tanswer;

        if(tanswer == result && time(NULL) < (oldtime+timelimit)) {
            atrue++;
            cout << endl << "Deine Antwort war RICHTIG!" << endl;
            cout << "Du hast nun " << atrue << " Aufgaben richtig beantwortet." << endl << endl;
        } else {
            afalse++;
            cout << endl << "Deine Antwort war leider falsch." << endl;
            cout << "Du hast " << atrue << " Aufgaben richtig," << endl;
            cout << "und " << afalse << " Aufgaben falsch beantwortet." << endl << endl;
        }

        cout << "Mochtest du eine neue Aufgabe?" << endl;
        cout << "J fur \'Ja\'" << endl;
        cout << "N fur \'Nein\'" << endl << endl;
        cout << "Neue Aufgabe? ";
        cin >> option;

        if((option == "J") || (option == "j") || (option == "Ja") || (option == "ja")) endprog = false;
        elseif((option == "N") || (option == "n") || (option="Nein") || (option == "nein")) endprog = true;
        else {
            cout << option << " ist ein ungultiger Befehl." << endl;
            cout << "Bitte korrigiere deine Eingabe." << endl << endl;
            cout << "J fur Ja, N fur Nein" << endl << endl;
            option = NULL;
            while((option != "J") || (option != "j") || (option != "N") || (option != "n")) {
                cout << "Deine neue Auswahl: ";
                cin >> option;

                if((option == "J") || (option == "j") || (option == "Ja") || (option == "ja")) endprog = false;
                elseif((option == "N") || (option == "n") || (option="Nein") || (option == "nein")) endprog = true;
            }
        }
    }

    cout << "Und Tschuss!" << endl;
    cout << "Bis zum nachsten Mal." << endl << endl;
}

Danke
ps: Ja ich weiß, an manchen Stellen hät man sich mit Funktionen oder sonst was Arbeit ersparen können, aber ich bin eben noch Anfänger.

[LordJaxom]

Ist das "elseif" ein Tippfehler? Solch ein Schlüsselwort gibt es in C++ nicht, dafür kannst Du die Kombination aus "else" und "if", sprich "else if" verwenden

(Tipp: Mit nem guten Syntaxhighlighting, wie hier im Board, sieht man sowas schnell)

[Nite]

Ouh, ich kenn das aus PHP so. ^^
Ich habe es nun getrennt voneinander und es kommen dennoch ein paar Meldungen:

1mal1.cpp: In function `int main()':
1mal1.cpp:22: warning: NULL used in arithmetic
1mal1.cpp:61: error: no match for 'operator||' in '(std::operator== [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*)(&option))), ((const char*)"N")) || std::operator== [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*)(&option))), ((const char*)"n"))) || (&option)->std::basic_string<_CharT, _Traits, _Alloc>::operator= [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const char*)"Nein"))'
1mal1.cpp:61: note: candidates are: operator||(bool, bool) <built-in>
1mal1.cpp:66: error: ambiguous overload for 'operator=' in 'option = 0'
C:/msys/mingw/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h:422: note: candidates are: std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]
C:/msys/mingw/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h:433: note:                 std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(const _CharT*) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]
C:/msys/mingw/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h:447: note:                 std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(_CharT) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]
1mal1.cpp:72: error: no match for 'operator||' in '(std::operator== [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*)(&option))), ((const char*)"N")) || std::operator== [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)((const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*)(&option))), ((const char*)"n"))) || (&option)->std::basic_string<_CharT, _Traits, _Alloc>::operator= [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>](((const char*)"Nein"))'
1mal1.cpp:72: note: candidates are: operator||(bool, bool) <built-in>

Das macht mir sorgen, da es ja oben geklappt hat, mit dem ||-Operator, wieso hier nicht?!

Danke

[CStoll]

Der Reihe nach die Fehler aufgedröselt:

• Zeile 22: NULL ist zwar definiert als 0, aber semantisch für Zeiger zu verwenden. Ganzzahltypen verwenden eine blanke 0.
• Zeile 61: Ein kleiner Schusselfehler - du hast dort anstelle des Vergleichs "option=="Nein"" die Zuweisung "option="Nein" verwendet - und die liefert nichts zurück, was der Compiler verODERn könnte.
• Zeile 66: Hier kann sich der Compiler nicht entscheiden, ob der die NULL als char* oder als char umwandeln soll - beides ist gleich gut. Und einen std::string leerst du besser mit option.clear(); oder option="";

[Nite]

Okay, danke, nun funktioniert es - zumindest vom Kompilieren her. Den Rest schaffe ich, denke ich, auch so.

Danke

[*D*Evil]

Hmm ... etwas "edler"

#include <iostream>
#include <ctime>
#include <string>
#include <sstream>
#include <cstdlib>
#include <algorithm>
#include <cctype>

template<typename T> T read_type(std::string const &prompt)
{
	T result;
	std::istringstream isstr;
	std::string line;

	do {
		std::cout << prompt << std::flush;

		std::getline(std::cin, line);

		isstr.clear();
		isstr.str(line);
		isstr >> result;
	} while(!isstr);

	return result;
}

int main() 
{
	std::cout << "1*1 Uebungsprogramm V0.1 BETA" << std::endl;

	unsigned short time_limit = 0;
	do { time_limit = read_type<unsigned short>("Zeitlimit je Aufgabe (in Sekunden) [1 - 60]: "); } while (time_limit > 60);

	std::cout << "Du hast als Zeitlimit" << time_limit << " Sekunden gewaehlt." << std::endl;
	std::srand(std::time(NULL));

	bool programm_end = false;
	for (unsigned short n = 1; !programm_end; ++n)
	{
		unsigned short value_left = std::rand() % 10 + 1;
		unsigned short value_right = std::rand() % 10 + 1;

		std::cout << "Aufgabe " << n << ": " << value_left << " * " << value_right << std::endl;
		std::time_t time = std::time(NULL) + time_limit;
		unsigned short result = read_type<unsigned short>("Ergebnis: ");
		unsigned short trys = 1;
		for (; time > std::time(NULL) && result != (value_left * value_right); ++trys)
		{
			std::cout << "Falsch! Versuche es noch einmal! (noch " << (time - std::time(NULL)) << "Sekunden!)" << std::endl;
			result = read_type<unsigned short>("Ergebnis: ");
		}
		std::cout << "Du hast nach " << trys << " Versuchen die aufgabe " << (result != (value_left * value_right) ? "nicht" : "") << " erfolgreich geloest!" << std::endl;
		std::string answer;
		do {
			std::cout << "Noch eine Aufgabe? (j / n)" << std::endl;
			std::cin >> answer;
			std::transform(answer.begin(), answer.end(), answer.begin(), std::tolower);
		} while (answer.at(0) != 'j' && answer.at(0) != 'n');

		programm_end = (answer.at(0) == 'n');
	}
}