ich habe eine Liste von Events welche alle eine Art "Soll-Zeit" haben zu welcher sie frühstens abgearbeitet werden sollen.
Neue Events sollen dabei sortiert nach der Zeit in meine Liste eingefügt werden, das Abarbeiten der Events soll dann auf der garantiert immer schon sortierten Liste geschehen.

Momentan benutze ich eine std::multimap< float, IEvent* >, wobei der Schlüssel die Abarbeitungszeit beinhaltet. Beim Einfügen eines neuen Elements in meine multimap wird ja das less-ordering beibehalten.

Das abarbeiten der "Liste" (multimap) mache ich dann wie folgt:

//iterate through delayed event queue
DelayedEventQueue::iterator it = m_DelayedEvtQueue.begin();
DelayedEventQueue::iterator itEnd = m_DelayedEvtQueue.end();
while( it != itEnd && it->first < fAktuelleZeit )
{
	IEvent *pEvt = it->second;
	FireEventImmediate( pEvt );
	it++;
}

if( it != m_DelayedEvtQueue.begin() )
	m_DelayedEvtQueue.erase( m_DelayedEvtQueue.begin(), it-- );

Nun zu meiner Frage: haltet ihr das für eine gute (effektive) Lösung, und wenn nicht was würdet ihr ansonsten empfehlen?

bool EventGreater( const IEvent &*pEvt1, const IEvent &*pEvt2 )
{
    return pEvt1->GetProcessTime() > pEvt2->GetProcessTime();
}

typedef std::priority_queue<IEvent*, std::vector<IEvent*>, &EventGreater> DelayedEventList;

class CEventComparison
{
public:
	bool operator()( const IEvent *pEvtLeft, const IEvent *pEvtRight ) const {
		return pEvtLeft->GetProcessTime() > pEvtRight->GetProcessTime();
	}
};

typedef std::priority_queue<IEvent*, std::vector<IEvent*>, CEventComparison> DelayedEventQueue;

Ich bekomme nur leider den Fehler: "Fehler 1 error C2039: 'GetProcessTime': Ist kein Element von 'IEvent'", und das obwohl in meiner IEvent-Klasse ganz eindeutig steht:

inline const float &GetProcessTime( void ) const { return m_fProcessTime; }

Bin grad etwas ratlos.

//EDIT:
*Facepalm*

#ifdef _CLIENT
	inline const float &GetProcessTime( void ) const { return m_fProcessTime; }
	inline void SetProcessTime( const float &time ) { m_fProcessTime = time; }
#endif

Man sollte dann natürlich die CEventComparison Class auch mit #ifdef umschließen -.-

Vielen Dank

class Event
{
public:
    Event(float time) : time_(time){}
    float GetProcessTime() const { return time_; }
    virtual void Fire() const = 0;
private :
    float time_;
};

class HalloEvent : public Event
{
public:
    HalloEvent(float time) : Event(time){}
    void Fire() const
    {
        std::cout << "Hallo\n";
    }
};

class EventComparison
{
public:
    bool operator()( const Event *lh, const Event *rh ) const {
        return lh->GetProcessTime() > rh->GetProcessTime();
    }
}; 

template<typename Queue>
void FireNext(Queue& eventQueue)
{
    Event* nextEvent = eventQueue.top();
    // hier sollte man unbedingt noch über Ausnahmesicherheit nachdenken!
    eventQueue.pop();
    nextEvent->Fire();
    delete nextEvent;
}

int main()
{
    typedef std::priority_queue<Event*, std::vector<Event*>, EventComparison> DelayedEventQueue;
    DelayedEventQueue queue;
    queue.push(new HalloEvent(1.0));
    while(!queue.empty())
        FireNext(queue);

    return 0;
}

//EDIT:
*Facepalm*

#ifdef _CLIENT
	inline const float &GetProcessTime( void ) const { return m_fProcessTime; }
	inline void SetProcessTime( const float &time ) { m_fProcessTime = time; }
#endif

Oh. Also #ifdefs innerhalb von Klassendefinition ist ganz schön pervers. Und dass der Returntyp von GetProcessTime "const float&" statt "float" ist, find' ich auch komisch.

inline const float &GetProcessTime( void ) const { 
#ifdef _CLIENT
		return m_fProcessTime;
#else
		return 0.0f;
#endif
	}

	inline void SetProcessTime( const float &time ) { 
#ifdef _CLIENT
		m_fProcessTime = time; 
#endif
	}

Ich weis, habs grad geändert in:

Jetzt hast du es durch etwas Schlimmeres ersetzt. Als Nicht-Client kann man die Methoden zwar benutzen, aber sie bewirken nichts. Stell dir mal vor, das Makro wird versehentlich nicht mehr definiert. Ob das wohl so schnell jemand bemerkt?

Außerdem solltest du den Wert nicht per Referenz zurückgeben. Darf man das mit dem Literal überhaupt?

Achso was soll an "const float&" ungewöhnlich sein? Will nur unnützes Kopieren verhindern. Mag sein dass der Compiler das auch so optimieren würde aber ich gehe lieber sicher, gerade weil die Methode durch die Aufrufe innerhalb der priority_queue hunderte mal pro Sekunde benutzt wird. Und da will ich sicher sein dass alles korrekt, vorsicht Denglisch, ge-inlined wird.

Mal ne Frage nebenbei, bei Visual Studio 2010, werden da Funktionen mit __forceinline auch im Debug-Build inlined obwohl Inlining da deaktiviert ist? Gibt son paar Sachen in meiner Mathe-Bib die ich gerne auch im Debug inlinen würde.

Achso was soll an "const float&" ungewöhnlich sein? Will nur unnützes Kopieren verhindern. Mag sein dass der Compiler das auch so optimieren würde aber ich gehe lieber sicher, gerade weil die Methode durch die Aufrufe innerhalb der priority_queue hunderte mal pro Sekunde benutzt wird. Und da will ich sicher sein dass alles korrekt, vorsicht Denglisch, ge-inlined wird.

Mal ne Frage nebenbei, bei Visual Studio 2010, werden da Funktionen mit __forceinline auch im Debug-Build inlined obwohl Inlining da deaktiviert ist? Gibt son paar Sachen in meiner Mathe-Bib die ich gerne auch im Debug inlinen würde.

Referenzen gibt es auch nicht umsonst, daher ist die Rück- bzw. Übergabe von integrierten Typen per Referenz aus Performancegründen nicht sinnvoll. Genauso wie das Benutzen von inline . Das inline Schlüsselwort solltest Du eigentlich fast nie brauchen, ausser um bei Funktionen die ODR nicht zu verletzen.
Im Allgemeinen soltlest Du Dich entspannen und den Compiler machen lassen. Der ist im Optimieren sehr gut und weiß viel besser als Du was zu tun ist.

Der ist im Optimieren sehr gut und weiß viel besser als Du was zu tun ist.

Das will ich hoffen.

Könntest du auf die Performance bei Referenzen-Übergabe nochmal genauer eingehen?

brotbernd schrieb:

Der ist im Optimieren sehr gut und weiß viel besser als Du was zu tun ist.

Das will ich hoffen.

Könntest du auf die Performance bei Referenzen-Übergabe nochmal genauer eingehen?

Referenzen sind auf niedriger Ebene nichts anderes als Zeiger (sie sind C++ Syntax-Sugar um Operatorenüberladung netter implementieren zu können).

Dh. wenn du auf einen Wert hinter einer Referenz zugreifst, muss der auch erstmal dereferenziert werden, was aber auch nur bei primitiven Typen nen Unterschied macht.

Im Endeffekt ist es praktisch egal, gewöhn dir einfach an alles was in kein Register passt per Referenz zurückzugeben, den Rest per Value.
Float passt super in ein Register, also ist die Rückgabe per const reference Schwachsinn.