Jetzt will ich natürlich jede Form von manueller Speicherverwaltung vermeiden, weshalb ich mir sowas vorstelle:

void callback(buffer);

vector<uint8_t> buffer(1024);
start_operation(move(buffer), callback); // user muss sich nicht mehr um Lifetime von buffer kümmern

/* ... */
// irgendwo in der Library, wenn die Operation fertig ist:
callback(move(buffer)); // gib Puffer an Nutzer zurück (per Move-Konstruktor)

void callback(buffer b) { /* ... */ }

Mein Problem: wie bekomme ich das generisch (mit Templates/allgemeinen Typen) hin? Wenn die Operation abgeschlossen ist, habe ich prinipiell nur einen Pointer auf den Puffer (bzw. auf ein Objekt, welches den Puffer dann beinhaltet), der Typ ist verloren. Die Typen-Information rette ich mir mit virtual-Funktionen, also dispatche damit unterschiedliche Operations-Typen (lesen/schreiben/abbrechen etc.). Aber kann ich auch irgendwie das Typen-System von C++ benutzen, um die Template-Parameter mitzunehmen? Wenn ich das alles nicht manuell machen will, fällt mir spontan nur noch RTTI, also typeid ein.

Hat jemand einen Tipp?

void start_read_operation(buffer&& b, callback_function callback) {
    unique_ptr<operation> new_operation(new read_operation(b, callback)); // Polymorph!
    new_operation->start();
    new_operation.release();
}

// Callback-Thread:
void callback_thread() {
   while(1) {
      operation* op = wait_for_operation_to_complete();
      unique_ptr<operation> op_ptr(op); // RAII
      op->callback(std::move(op->buffer)); // Hier weiß ich nicht mehr, ob es eine read/write/whatever Operation ist, aber callback ist virtuell
   }
}

Jetzt will ich aber ein Funktionstemplate benutzen:

template <typename BufferType>
void start_read_operation(BufferType&& buffer, callback_function callback) { /* ... */ }

Und genau da hapert's, da ich den Typ irgendwie dynamisch kodieren muss.

Kannste nicht beim virtual Dispatch in operation nicht direkt start_read_operation aufrufen?

Wie meinst du das? operation::callback wird erst aufgerufen, nachdem irgendwann die Operation fertig ist, die mit start_read_operation() begonnen wurde.

Die Funktion wait_for_operation_to_complete() wartet eben so lange, bis irgendeine Operation fertig ist (egal ob read/write/bla). Aber an der Stelle kenne ich den Typ der Operation nicht mehr, deshalb virtual. Aber jetzt müsste operation ja auch ein Template werden, um den Buffer-Type zu generalisieren. Nur wie rette ich diesen Typen über die Laufzeit?

?

Mach einfach CallbackType const& draus.

Edit: Nicht vergessen, einen virtual-Destruktor hinzuzufügen!