automatico classe proxy

Question

Si supponga che ho un'interfaccia

class I{ 
public: 
    virtual void f(int id)=0; 
    virtual void g(int id, float x)=0; 
} 

Ho bisogno di una classe proxy, a fare una sorta di id per la mappatura puntatore

class Proxy : I 
{ 
    I * i[5]; 
public: 
    void f(int id) 
    { 
     i[id]->f(id); 
    } 

    void g(int id, float x) 
    { 
     i[id]->g(id, x); 
    } 

} 

Così, quando scrivo

Proxy *p; 
p->f(1); 

f viene richiamato sull'oggetto con id = 1

ci sono molti di questi casi e le interfacce sono piuttosto grandi. Quindi non voglio codificare tutte le funzioni nella classe proxy. C'è un modo per farlo automaticamente? magari usando le macro, modelli, sovraccarico "->", ecc

Answer 1

La soluzione facile è definire un operatore-> che restituisce il puntatore all'interfaccia. Ma questo interromperà l'incapsulamento poiché tutti possono accedere direttamente ai tuoi oggetti e in realtà non hai bisogno della tua classe proxy (potresti anche usare semplicemente una std :: map).

alternativa si potrebbe fare qualcosa di simile

template <typename Interface> 
class Proxy 
{ 
    Interface* interfaces[5]; 
public: 
    template <typename F, typename... Params> 
    auto operator()(F f, const int id, Params... parameters) 
      -> decltype((interfaces[id]->*f)(id, parameters...)) 
    { return (interfaces[id]->*f)(id, parameters...); } 
}; 

Essa si basa pesantemente su C++ 11 caratteristiche quindi potrebbe non compilare con il compilatore.

Prima utilizza i modelli Variadic. Vedere https://en.wikipedia.org/wiki/Variadic_Templates per ulteriori informazioni.

Successivamente utilizza decl_type. Vedi https://en.wikipedia.org/wiki/Decltype per ulteriori informazioni.

Devi usare in questo modo:

Proxy<I> p; 
    ... 

    p(&I::f,1); 
    p(&I::g,3, 1.); 

Answer 2

Non so se questo è adatto per voi, ma si può prendere cura di questo usando puntatori a funzioni ...

es.

#include <stdio.h> 

typedef void (*f)(int); 

void f1(int a) 
{ 
    printf("f1: %d\n", a); 
} 
void f2(int a) 
{ 
    printf("f2: %d\n", a); 
} 
int main(int argc, char *argv[]) 
{ 
    f array[5] = {NULL}; // create array of pointers 
    array[0] = f1; // assign different functions on them 
    array[1] = f2; // -||- 

    array[0](10); // call them 
    array[1](12); 

    // and you end up with something like "array[i]();" in your proxy class... 
}