ich möchte die SetTimer(...) Funktion in einer Wrapper Klasse verpacken in der ich über das Publisher-Subscriber-Pattern Listener registrieren kann, die über das TimeEvent informiert werden sollen.

Ich möchte das die o. g. Wrapper-Klasse als Thread erstellt wird. Wie kann ich das denn realisieren ?

Ich habe im folgenden meine "Timer.h" und "TimeEventListener.h" anghängt. Meine bisjetzige "TImer.cpp" bzw. einzelne Implementierungen kann ich auf Anfrage ebenfalls posten.

TimeEventListener.h

#pragma once

class TimeEventListener
{
public:
	void PerformTimeOutEvent(void);
};

Timer.h

#include <windows.h>
#include <list>
#include <map>

#include <iostream>

#include "TimeEventListener.h"

using namespace std;

class Timer
{
private:

	unsigned int milliseconds;

	unsigned int id;

	list<TimeEventListener*> timeEventListeners;

	static map<unsigned int, list<TimeEventListener*>*> timeEventListenersMap;

public:

	Timer(unsigned int milliseconds);

	~Timer(void);

	void SetInterval(unsigned int milliseconds);

	unsigned int GetIntervall(void);

	void Start (void);

	void Stop (void);

	void InsertTimeEventListener(TimeEventListener* listener);

	void RemoveTimeEventListener(TimeEventListener* listener);

private:

	//Thread Methode
	static void StartThread (void* parameters)
	{
	}

	//Timer Methode
	static void CALLBACK PerformTimeEvent(HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc)
	{
	}

};

Gruß und Danke

also ich möchte den Timer mit dem Konstruktor erstellen und mit dem Zeitintervall in Millisekunden initialisieren können.

Timer(unsigned int milliseconds);

Die Klasse Timer soll aber auch ein Thread sein. Nur weiss ich nicht genau ob ich die Funktion

uintptr_t _beginthread( 
   void( __cdecl *start_address )( void * ),
   unsigned stack_size,
   void *arglist 
);

im Konstruktor von Timer aufrufen soll oder in der Methode

[
void Start (void);
/cpp]

Mit den Methoden

[cpp]
void InsertTimeEventListener(TimeEventListener* listener);

void RemoveTimeEventListener(TimeEventListener* listener);

soll man Referenzen von Klassen registrieren bzw. entfernen können, die von TimeEventListener ableiten. Sind diese Referenzen registriert wird vo jeder die Methode

void PerformTimeOutEvent(void);

aufgerufen und die Listener werden über das Zeit-Event informiert und können ihre Zeitgesteuerte Funktionalität ausführen.

Der Thread soll so lange ablaufen, bis die Methode

void Stop (void);

aufgerufen wird.

#include "Timer.h"

#include <process.h>

Timer::Timer(unsigned int milliseconds)
{
	this->SetInterval(milliseconds);
}

Timer::~Timer(void)
{
}

void Timer::SetInterval(unsigned int milliseconds)
{
	this->milliseconds = milliseconds;
}

unsigned int Timer::GetIntervall(void)
{
	return this->milliseconds;
}

void Timer::Start(void)
{
	unsigned int milliseconds = this->GetIntervall();
	unsigned int id = 1;
	SetTimer(NULL, id, milliseconds, &(TIMERPROC)PerformTimeEvent);
	cout << "1" << endl;
	Timer::timeEventListenersMap.insert(make_pair(id, &this->timeEventListeners));
	cout << "2" << endl;
	HANDLE thread = reinterpret_cast<HANDLE>(_beginthreadex(NULL, 0, StartThread, NULL, CREATE_SUSPENDED, id));
	cout << "3" << endl;
}

void Timer::Stop(void)
{
	unsigned int id = 1;
	KillTimer(NULL, id);
	Timer::timeEventListenersMap.erase(id);
}

void Timer::InsertTimeEventListener(TimeEventListener* listener)
{
	this->timeEventListeners.push_front(listener);
}

void Timer::RemoveTimeEventListener(TimeEventListener* listener)
{
	this->timeEventListeners.remove(listener);
}

map<unsigned int, list<TimeEventListener*>*> Timer::timeEventListenersMap;

int main (void)
{
	Timer timer = Timer(5000);
	timer.Start();
	return (0);
}