Funkcja czasu w tle

Witam,

Chcę napisać program, w którym będę wprowadzał dane do tablicy - będzie ona składnikiem jakiejś klasy. Chciałbym żeby w tle liczony był "czas życia" poszczególnych elementów tablicy. Chodzi o to, żeby "z automatu" usuwane były wpisy w tablicy, które istnieją dłużej niż np.: 60 sekund, a w między czasie żebym mógł bez przeszkód (przestojów w czasie) obsługiwać program. Cały dzień spędziłem na szukaniu rozwiązania do tego problemu, jednak nigdzie nie mogę znaleźć odpowiedniego rozwiązania. Czytałem że można napisać Timer który by się tym zajmował, tylko za bardzo nie wiem jakby to mogło wyglądać. Proszę o jakąś podpowiedź bo nie mam pojęcia jak to ugryźć.

W grę nie wchodzi funkcja GetTickCount()

Użyj wątków, wątków użyj. Może nie najłatwiejsze podejście, ale zadziała.

Rzeczywiście, nie pomyślałem o wątkach i chyba tutaj tylko one mogą zadziałać. Tylko teraz pytanie jest takie: Skoro każdy wpis w tablicy będzie wykonany w innym czasie to tworzyć osobny wątek dla każdego wpisu w tablicy? I na jego końcu wywoływać funkcję, która będzie go usuwać z tablicy? Problem w tym, że nie wiem za bardzo jak powiązać samą tablicę, która będzie w jednej w klasie z Timerem który będzie odrębną klasą...
Zrobić analogiczną tablicę w timerze, gdzie pod tymi samymi indeksami tablicy będę umieszczał czasy dodania wpisów?

Najprościej użyj timera który co 60 sekund będzie przeszukiwal tablice i usuwał stare wpisy. Nie wiem jaki jesteś w programowaniu ale czuję że na wątkach możesz się wyłożyć i będzie kolejny temat :)

A moze wcale nie potrzebujesz wątków? Czy to usuwanie musi byc realizowane w czasie rzeczywistym? Jezeli nie (a wydaje mi sie, ze nie, skoro masz jednowatkowa aplikacje) to mozesz do kazdego elementu przypisac czas jego wstawienia i przed kazda operacja na tablicy (insert, delete, odczyt jakiegos elementu) usuwac "stare" elementy.

Ogólnie biorę się za programowanie po dłuższej przerwie. Zaawansowany nie byłem, ale z wątkami miałem jako tako do czynienia (raczej w miarę szybko załapię). W timerze chodzi o to, że ma on nie blokować działania samego programu. Ma to działać na zasadzie takiej, że dla każdego wpisu powinien być ustawiony taki sam kwant czasu (np. 60 sekund) i Od razu po jego minięciu wpis powinien zostać usunięty. Wiadomo, że wszystkich wpisów nie zrobię w jednym momencie. Odstępy czasowe między wpisami mogą być różne. Jeśli zrobię timer, który co 60 sekund będzie sprawdzał wpisy, to może się zdarzyć, że wpis będzie istniał np. 119 s. co nie powinno mieć miejsca. Z tego wniosek że powinno się to odbywać w czasie rzeczywistym.

Jakie znaczenie ma to czy program jest jednowątkowy czy nie przy czasie rzeczywistym?

A jakie znaczenie ma tak naprawde czy usuniesz element dokladnie po czasie 60 sekundach czy po 20 minutach? Tzn. nie wykluczam, ze tak nie jest (nie napisales tak naprawde po co Ci to), ale jezeli operujesz na jednym wątku to tak naprawde jest dla Ciebie istotne to, żeby po czasie 60 sek. ten element nie istniał. Przykład: program mający dwie (bardzo rozbudowane ;-) ) funkcje, dodawanie elementu do listy i wyświetlanie listy (+twoje założenie usunięcia elementu po 60 sek). Operacje wprowadzania tekstu są blokujące (synchroniczne), wprowadzasz 3 elementy dajmy na to w odstępach czasu 30 sekund. Czekasz jeszcze 30 sekund, wybierasz opcję listowania elementów, funkcja weryfikująca usuwa dwa pierwsze elementy (delta t >= 60 sec), następuje prezentacja listy, w wyniku widzisz jedynie ostatnio dodany element (dt < 60 sec). Wszystko działa tak jak chcesz. Daze do tego, ze jezeli program działa tylko i wylacznie na jednym watku i nie jest zalezny od innych czynnikow zewnetrznych to byc moze nie warto wprowadzac tu watkow do usuwania elementow dokladnie po okreslonym czasie gdzyz i tak nie bedzie to mialo wplywu na dzialanie Twojego programu.

Sam kiedys znalazlem ta klase kiedy szukalem sposobu na odmierzanie czasu. Tylko jest jedno ale, bo u mnie w petli glownej wykonywal sie caly program i po prostu na poczatku bylo sprawdzenie czasu czy juz nie uplynal. Powiedzmy masz while na poczatku sprawdzasz czas i lecisz dalej robisz sobie cos tam zakladam ze nie bedzie to trwalo nie wiadomo ile czasu i od nowa na poczatek sprawdzasz czas.

Ew. podepnij sie pod licznik zegara z tego co pamietam on 18 razy na sekunde jest obslugiwany przez sterownik przerwan. Dorzuc mu tam cos od siebie i tyle ;p

Zartuje oczywiscie troche to trudne i w cpp raczej niemozliwe do wykonania ;)

//////////////////////////////////////////
// class declaration:


class timer {
        public:
                timer();
                void           start();
                void           stop();
                void           reset();
                bool           isRunning();
                unsigned long  getTime();
                bool           isOver(unsigned long seconds);
        private:
                bool           resetted;
                bool           running;
                unsigned long  beg;
                unsigned long  end;
};


//////////////////////////////////////////
// class implementation:


timer::timer() {
        resetted = true;
        running = false;
        beg = 0;
        end = 0;
}


void timer::start() {
        if(! running) {
                if(resetted)
                        beg = (unsigned long) clock();
                else
                        beg -= end - (unsigned long) clock();
                running = true;
                resetted = false;
        }
}


void timer::stop() {
        if(running) {
                end = (unsigned long) clock();
                running = false;
        }
}


void timer::reset() {
        bool wereRunning = running;
        if(wereRunning)
                stop();
        resetted = true;
        beg = 0;
        end = 0;
        if(wereRunning)
                start();
}


bool timer::isRunning() {
        return running;
}


unsigned long timer::getTime() {
        if(running)
                return ((unsigned long) clock() - beg) / CLOCKS_PER_SEC;
        else
                return end - beg;
}


bool timer::isOver(unsigned long seconds) {
        return seconds >= getTime();
}


//////////////////////////////////////////