wie kann ich einen asynchronen Funktionsaufruf umsetzen?

Ich möchte eine Funktion aufrufen, die jedoch nicht sofort bearbeitet wird, sondern sich zunächst in die "Warteschleife" zum Abarbeiten einreiht und damit erst später ausgeführt wird.

Dann passt das mit function und bind . Wenn Dein Compiler neu genug ist:

#include <functional>

std::tr1::function <void ()> f(std::tr1::bind(&class_type::method, &object, arg1, arg2));

//...

f(); // object.method(arg1, arg2);

ansonsten mit boost:

#include <boost/function.hpp>
#include <boost/bind.hpp>

boost::function <void ()> f(boost::bind(&class_type::method, &object, arg1, arg2));

//...

f(); // object.method(arg1, arg2);

<boost/bind.hpp> und <boost/function.hpp> kennt der Compiler leider auch nicht.

Was nun?

QueueUserAPC(Funktion,Thread,Parameter);

Verzögert aufrufen? Kein ding:

BOOL WINAPI CreateTimerQueueTimer(
  __out     PHANDLE phNewTimer,
  __in_opt  HANDLE TimerQueue,
  __in      WAITORTIMERCALLBACK Callback,
  __in_opt  PVOID Parameter,
  __in      DWORD DueTime,
  __in      DWORD Period,
  __in      ULONG Flags
);

...

Ist grausig anzusehen und nicht portabel (Weil WinAPI, wenn ich das richtig entziffere). Dann doch lieber, was die Vorposter geschrieben haben

Ich nutze VS2008 SP1. Mein Compiler kennt zwar <functional>, jedoch nicht std::tr1::function bzw. std::tr1::bind.

#include <iostream>
#include <functional>
#include <queue>

void fun(int a, double b)
{
    std::cout << "a: " << a << ", b: " << b << std::endl;
};

int main()
{
    typedef std::tr1::function<void ()> command_type;
    typedef std::queue<command_type> command_queue_type;

    command_queue_type command_queue;

    command_queue.push(std::tr1::bind(&fun, 42, 3.14159));

    std::cout << "la li lueue..." << std::endl;

    command_queue.front()();
    command_queue.pop();

}

Ausgabe:

la li lueue...
a: 42, b: 3.14159
Drücken Sie eine beliebige Taste . . .

Gebaut mit:

Microsoft Visual Studio 2008
Version 9.0.30729.1 SP

Ich möchte eigentlich folgendes:

void fun(int a, double b)
{
    std::cout << "a: " << a << ", b: " << b << std::endl;
};

void meth()
{      
    fun(5,10); // irgendwie asynchroner Funktionsaufruf!!!

    std::cout << "la li lueue..." << std::endl; // weitere Funktionen und Methoden
    // usw.   
} // nach Abschluss der Funktion wird die Funktion aufgerufen

Prinzipiell soll es also wie ein asynchrones Eventhandling funktionieren. Dabei wird der Delegate erst "am Ende des Codes" aufgerufen. Der Aufruf des Delegate hat sich nämlich in die Dispatcher Reihenfolge eingereiht und wird ausgeführt, sobald er an der Reihe ist...

fatal error C1083: Datei (Include) kann nicht geöffnet werden: "boost/function.hpp": No such file or directory

Ist "#include <boost/function.hpp>" eine Standardbibliothek? Denn leider kann ich sie nicht ohne Weiteres hinzufügen:

fatal error C1083: Datei (Include) kann nicht geöffnet werden: "boost/function.hpp": No such file or directory

Nein, Boost gehört nicht zur C++ Standard Library.

http://www.boost.org/
http://www.boostpro.com/download/

Was nun?

Informationen zu Boost findest du auf deren Seite, für MSVC gibt es sogar einen Installer.

Mir fällt es derzeit relativ schwer einen Einstieg zu finden, den asynchronen Funktionsaufruf durch zu führen. Boost bietet ja eben noch vieles mehr an Funktionalitäten... Wo soll ich anfangen zu suchen?