Problem mit C++ 11 chrono

[Crymes]

Hi,
ich probiere gerade eine simple Stoppuhr in C++ zu schreiben.
Das ist mein Code:

using namespace std;

std::chrono::steady_clock::time_point lastaction;

void updateTime()
{
    lastaction = std::chrono::steady_clock::now();
}
std::chrono::duration<double> getTimeSinceLastAction()
{
    std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
    std::chrono::duration<double> diff = now - lastaction;
    return diff;
}
int main()
{
    updateTime();
    cout << getTimeSinceLastAction().count();
    return 0;

Das funktioniert auch ohne Probleme.
Wenn ich jetzt allerdings den Rückgabetyp ändere zu

using namespace std;

std::chrono::steady_clock::time_point lastaction;

void updateTime()
{
    lastaction = std::chrono::steady_clock::now();
}
std::chrono::duration<std::chrono::milliseconds> getTimeSinceLastAction()
{
    std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
    std::chrono::duration<std::chrono::milliseconds> diff = now - lastaction;
    return diff;
}
int main()
{
    updateTime();
    cout << getTimeSinceLastAction().count();
    return 0;

bekomme ich den Fehler "error: static assertion failed: rep cannot be a duration".

Weiß jemand wie man das mit dem Rückgabetyp vernünftig macht? Weil ich will nicht dass das grad nur durch Zufall funktioniert, der Code muss 100% verlässlich sein

 

[Forsaiken]

std::chrono::duration<double, std::milli> getTimeSinceLastAction()
{
    auto now = std::chrono::steady_clock::now();
    auto diff = now - lastaction;
    return diff;
}

Weitere Infos hier

 

[Crymes]

Danke, habs jetzt glaub verstanden.
wenn ich das auto noch ersetze sollte es so stimmen, oder? Funktionieren tuts auf jeden Fall.

std::chrono::milliseconds getTimeSinceLastAction()
{
    std::chrono::steady_clock::time_point tp = std::chrono::steady_clock::now();
    std::chrono::steady_clock::duration diff = tp - lastaction;
    st::chrono::milliseconds s = std::chrono::durationn_cast<std::chrono::milliseconds>(diff);
    return diff;
}

Ich stoße in letzter Zeit immer wieder auf ein Problem mit Objekten im Header (hab viel Java gemacht, da war das kein Problem).
Wenn ich jetzt in meinen Header unter protected "std::chrono::steady_clock::time_point lastaction" schreibe, dann wird noch vor dem Aufruf des Konstruktors ein neues Objekt vom Typ time_point angelegt, oder?
Wenn ich jetzt in meiner update Funktion "lastaction = std::chrono::steady_clock::now();" schreibe, was passiert dann mit lastaction?
Wird das erste lastaction Objekt unreferenziert rumgammeln bis ich das übergeordnete Objekt lösche?
Ruft now() intern new auf und gibt mir eine Referenz zurück, weil sonst ist lastaction nach dem Ende der Funktion wieder gelöscht durch das Blockende?
Odern kann man in C++ Objekte als solche zurückgeben?

 

[bingo88]

Warum willst du das auto ersetzen?

Du bekommst in dem Fall beim Aufruf keine Referenz sondern ein komplettes Objekt ("by value"). Das alte Objekt wird quasi überschrieben. Wenn lastaction eine Klassenvariable ist, wird das auch nicht beim Verlassen der Funktion gelöscht, sondern im Destruktor der Klasse. Und ja, Klassenvariablen werden vor dem Aufruf des Konstruktorbodys initialisiert.

 

[Crymes]

Weil ich das auto nicht kenn

Ist es eigentlich eine gute Idee ein Thread Objekt als Klassenvariable zu definieren ?
Also sowas wie "std::thread T(&Klassennme::startfunktion, this)".
Wenn ich dann detatch() aufrufen würde und das Objekt worin der Thread sich befindet gelöscht wird bekomm ich ein Problem, oder ?

 

[bingo88]

auto ist Teil des neuen automatischen "Typerkennungssystems".

auto x = std::string("demo"); // x hat nun den Typ std::string

Bei so einfachen Sachen wie string merkt man das nocht nicht so richtig, aber "std::map<std::string, std::string>::const_iterator" wäre ein guter Kandidat für auto:

std::map<std::string, std::string> theMap;
//...
std::map<std::string, std::string>::const_iterator iter1 = theMap.cbegin(); // lang
auto iter2 = theMap.cbegin(); // kurz

Das mit dem Thread siehst du richtig, dem solltest du sein Objekt nicht unterm Hintern wegziehen Wenn das sichergestellt ist, kann man das aber als Klassenvariable laufen lassen. Ansonsten kann man sich auch ein Konstrukt mit einem std::shared_ptr basteln, da wird das Objekt erst zerstört, wenn die letzte Referenz futsch ist.