Modello RAII per acquisizione/rilascio con modelli variadici

Question

Sto tentando di sostituire tutte le mie classi RAII "Acquire/Release" (ne ho una per ogni tipo di risorsa al momento) con una sola classe basata su modelli. La forma generale di acquisizione è che alcuni tipi sono Acquire(), alcuni sono Acquisisci (p1), alcuni sono Acquisisci (p1, p2), ecc. Lo stesso è vero per il Release. Ma se una risorsa è acquisita con parametri, allora deve essere rilasciata con quegli stessi parametri.

Penso di poterlo fare con i modelli variadic, memorizzando gli argomenti in una tupla. Ovviamente sono caduto nella sintassi. Qualcuno può aiutare?

#include <tuple> 

template<class T, typename... Args> 
class Raii 
{ 
public: 

    Raii(T * s, Args&& ... a) : subect(s), arguments(a) 
    { 
     subject->Acquire(arguments); 
    } 

    ~Raii() 
    { 
     subject->Release(arguments); 
    } 

private: 

    T subject; 
    std::tuple<Args...> arguments; 
}; 

class Framebuffer 
{ 
public: 

    void Acquire() {} 
    void Release() {} 
}; 

class Sampler 
{ 
public: 

    void Acquire(int channel) {} 
    void Release(int channel) {} 
}; 

class Buffer 
{ 
public: 

    void Acquire(int target, int location) {} 
    void Release(int target, int location) {} 
}; 

int main(void) 
{ 
    Framebuffer f; 
    Sampler s; 
    Buffer b; 

    auto b1 = Raii(&f); 
    { 
     auto b2 = Raii(&s, 10); 
     { 
      auto b3 = Raii(&b, 10, 20); 
      { 

      } 
     } 
    } 
    return 0; 
} 

Answer 1

A parte alcune piccole cose come le discrepanze puntatore/valore, i problemi principali sono che non è possibile fare riferimento a Raii senza argomenti del modello e non si espande il parametro parameter pack/tuple.

Ecco una versione di lavoro che si potrebbe migliorare con alcuni spruzzi extra di inoltro perfetta ecc

template<class T, typename... Args> 
class Raii 
{ 
public: 

    Raii(T & s, Args&& ... a) : subject(s), arguments(a...) 
    { 
     //expand a 
     subject.Acquire(a...); 
    } 

    //helper to expand tuple 
    //requires std::index_sequence and friends from C++14 
    //if you are limited to C++11, you can find implementations online 
    template <std::size_t... Idx> 
    void release(std::index_sequence<Idx...>) 
    { 
     subject.Release(std::get<Idx>(arguments)...); 
    } 

    ~Raii() 
    { 
     //yay, index trick 
     release(std::index_sequence_for<Args...>{}); 
    } 

private: 

    T &subject; 
    std::tuple<Args...> arguments; 
}; 

//helper function so that we can deduce the Raii template args 
template <class T, typename... Args> 
Raii<T,Args...> make_raii (T & t, Args&&... args) { 
    return {t, std::forward<Args>(args)...}; 
} 

// Framebuffer etc. 

int main() 
{ 
    Framebuffer f; 
    Sampler s; 
    Buffer b; 

    //use make_raii instead of Raii 
    auto b1 = make_raii(f); 
    { 
     auto b2 = make_raii(s, 10); 
     { 
      auto b3 = make_raii(b, 10, 20); 
      { 

      } 
     } 
    } 
} 

Live Demo

Answer 2

Sono piuttosto sicuro che la magia sarebbe:

subject->Acquire(a...); 

Dal a è un pacchetto modello, è necessario espanderla per la chiamata.

L'espansione di una tupla in una chiamata variadica richiede integer_sequence expansion.