Zeitfunktion

Stromberg

Wie kann ich eine durchgehende Pausefunktion schreiben, ohne dass das ganze Programm stehen bleibt, sondern vll. nur eine Funktion gestartet wird. Also das ich vll. die Funktion "ZEIT" habe, und ich dann machen kann:

while(1)
{ 
   if ZEIT(5) func();
   cout << "HALLO" << endl;
}

Also wenn 5 Sekunden vorbei sind, dann soll func() aufgerufen werden. Und nach 5 Sekunden wird ZEIT halt neu gestartet und geht wieder von worne los. Und nach 5 Sekunden wird wieder func() aufgerufen.....
Aber es soll halt durchgehen sein, sodass auch das "HALLO" auf den Bildschirm geschrieben wird. Ist sowas möglich? Sollte man das dann vll. eher mit einer Klasse machen? Wie würdet ihr das jetzt umsetzen bzw. die Funktion ZEIT(...) machen?

MfG
Stromberg

.filmor

Sowas geht im Allgemeinen mit Threads. Aber wenn du noch nicht so sicher in der Sprache bist, solltest du die tunlichst vermeiden. Du musst dabei ziemlich darauf aufpassen, wer gerade worauf zugreift (hier zb wenn func auch etwas über std::cout ausgibt).

http://kharchi.de/threads.html
http://www.boost.org/doc/html/thread.html

/edit:

Dein Codebeispiel wäre dann eher sowas wie:

namespace
{
    template <typename Functype>
    void caller (Functype func, unsigned sec)
    {
        boost::xtime xt;
        boost::xtime_get (&xt)
        xt.m_sec += sec;
        boost::thread::sleep (xt);
        func ();
    }
}

template <typename Functype>
void call_after_sec (Functype func, unsigned sec)
{
    boost::thread (boost::bind (caller<Functype>, func, sec));
}

Ohne Gewähr

Stromberg

Aso, mh dann lass ich das mal lieber noch. Aber dann kann ich ja wenigstens eine "stop" Funktion schreiben, die mein Programm anhält. Hier:

inline bool events::stop(int milisecs) const
{
    int temp=time(0)+milisecs;
    while(1)
    {
        if (time(0)==temp)
        {
            return true;
        }
    }
}

Warum funktioniert das nicht da kommt immer:

events.hpp:12: warning: inline function `bool events::stop(int) const' used but never defined

und wenn ich die Funktion dann aufrufe;

events zeit;
zeit.stop(10000);
system("pause");

Kommt:

undefined reference to `events::stop(int) const'

???

MfG
Stromberg

*D*Evil

#include <ctime>

void events::stop(std::size_t ms) const
{
    std::size_t time = static_cast<std::size_t>(std::time(0)) + ms;
    while(std::time(0) <= time);
}

wäre das, was du versucht hast ...

.filmor

Und das ist nicht schön ;). Solche Sachen (die nichts mit eigentlichem Multithreading zu tun haben) ist es dann doch besser, anständige Funktionen zu nutzen. Zum einen liefert std::time afaik keine Genauigkeit im Millisekundenbereich, zum anderen ist das ein ziemlich geschäftiges Programm, dafür das es nichts tut (will heißen es verbrät wahrscheinlich beim Warten mehr CPU-Zeit als im eigentlichen Programmablauf!).
Du kannst entweder die plattformabhängiges wie Sleep (Windows) oder usleep (Unices) oder, wenn es schon installiert sein sollte, die plattformunabhängige Boost-Version benutzen. Der entsprechende Code wäre dann:

// Unix
#include <unistd.h>

void events::stop (std::size_t ms) const
{
    usleep (ms * 1000);
}

// Boost
#include <boost/thread/xtime.hpp>

void events::stop(std::size_t ms) const
{
    boost::xtime xt;
    boost::xtime_get (&xt, boost::TIME_UTC);
    xt.nsec += ms * 1000000;
    boost::thread::sleep (xt);
}

Ich kann verstehen, wenn dir Letzteres zu unhandlich ist

Zu Sleep kann ich nichts sagen.

hustbaer

Stromberg, was willst du denn erreichen?
Das was du beschreibst geht am ehesten wirklich mit Threads, aber wie schon geschrieben wurde sind Threads nicht so einfach (Achtung, Untertreibung!).

Vielleicht ist das was du letztendlich erreichen willst aber viel einfacher hinzubekommen?

BorisDieKlinge

Naja würde Stromberg nen Timer empfehlen, welcher alle X sekunden eine Funktion aufruft, und währendedesen die funktion aufgerufen wird, kann das progamm nichts anderes tun..

Naja ist allerdings nur gut, wenn diese Funktion nich lange braucht, ansonsten Threads:)

Bei Timer gibts halt keine Probleme mit gemeinsame ressourcenzugriff