c++ - know - Clase automática de proxy

windows 10 get proxy settings

Question

Suponer que tengo una interfaz

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

Necesito una clase proxy, para hacer algún tipo de mapeo de identificación a puntero

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);
    }

}

Entonces cuando escribo

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

f se invoca al objeto con id = 1

hay varios casos similares y las interfaces son bastante grandes. Así que no quiero codificar todas las funciones en la clase de proxy. ¿Hay forma de hacerlo automáticamente? tal vez usando macros, plantillas, sobrecarga "->" etc.

Answer 1

La solución fácil es definir un operador-> que devuelve el puntero a la interfaz. Pero esto romperá su encapsulamiento ya que todos pueden acceder a sus objetos directamente y usted realmente no necesita su clase proxy (también podría usar un std :: map).

Alternativa, podrías hacer algo como

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...); }
};

Se basa en gran medida en las características de C ++ 11 por lo que podría no compilarse con su compilador.

Primero usa las plantillas Variadic. Consulte https://en.wikipedia.org/wiki/Variadic_Templates para obtener más información.

Luego usa decl_type. Consulte https://en.wikipedia.org/wiki/Decltype para obtener más información.

Tienes que usarlo así:

  Proxy<I> p;
  ...

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

Answer 2

No sé si esto es adecuado para ti, pero podrías ocuparte de esto usando punteros a funciones ...

es decir.

#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...
}