Получение нескольких пакетов параметров шаблона класса varidiac через фабричный класс с вложенным классом - PullRequest
0 голосов
/ 04 октября 2019

TL; DR Пропустить раздел «Фон», перейти к «Проблема».

Фон : я пытаюсь реализовать шаблонный класс, который инкапсулирует функциюэто член другого класса, экземпляр этого класса и любые полупостоянные аргументы, которые должны быть предоставлены при последующем вызове функции в качестве обратного вызова. Для этого у меня есть следующая реализация и пояснительная реализация container и main:

template<class RET> class Callback_t {
public:
    virtual ~Callback_t() = default;
    virtual RET call() = 0;
};
template<class T, class RET, class... Args> class CallbackCreattimeArgs : public Callback_t<RET> {
public:
    std::shared_ptr<T> owner;
    RET(T::*x)(Args...);
    RET call() {
        return (*owner.*(x))(std::get<Args&&>(args)...);
    };
    std::tuple<Args&&...> args;
    CallbackCreattimeArgs(std::shared_ptr<T> t, RET(T::*x)(Args...), Args&&... args) : owner(t), x(x),
        args(std::tuple<Args&&...>(std::forward<Args>(args)...)) {}
    CallbackCreattimeArgs(T* t, RET(T::*x)(Args...), Args&&... args) :
        CallbackCreattimeArgs(std::shared_ptr<T>(t), x, std::forward<Args...>(args)...) {}
};
class container {
public:
    static void printFrom(container* c) { c->print(); };
    container(int data) : data(data) {};
    ~container() {};
    void print() { printf("%d\n", data); };
    void printTo(FILE* f) { fprintf(f, "%d\n", data); };
private:
    int data;
};
int main() {
    container c1(1), c2(20);
    CallbackCreattimeArgs<container, void> f1(&c1, &container::print);
    Callback_t<void>* fp1 = &f1;
    fp1->call();//1
    CallbackCreattimeArgs<container, void, FILE*> f2(&c2, &container::printTo, stdout);
    Callback_t<void>* fp2 = &f2;
    fp2->call();//20
}

Это работает, но не позволяет вызывающей стороне обратного вызова предоставлять какие-либо аргументы. Мне также удалось получить произвольный список аргументов, который должен был предоставить вызывающий объект, но за счет потери первоначального создателя. Я опубликую это, если потребуется, но я думаю, что это добавит больше объема, чем ясности.

Проблема: отредактированная, полностью переписанная здесь: Мне нужно поддерживать Windows и Linux. Я работал с Visual Studio 2017, но linux g ++ по-прежнему не компилируется. Это моя текущая версия g ++:

#include <tuple>
#include <stdio.h>

template<class RET, class... RArgs> class Callback_t {
public:
  virtual RET call(RArgs... rargs) = 0;
  virtual ~Callback_t() = default;
};

template<class RET, class... RArgs> class CallbackFactory {
private:
  template<class T, class... CArgs> class Callback : public Callback_t<RET, RArgs...> {
  private:
    T* owner;//TODO weak pointer?                                                                                                                                                                                                                                      
    RET(T::*x)(CArgs..., RArgs...);
    std::tuple<CArgs...> cargs;
    RET call(RArgs... rargs) {
      return (*owner.*(x))(std::get<CArgs>(cargs)..., rargs...);
    };
  public:
    Callback(T* t, RET(T::*x)(CArgs..., RArgs...), CArgs... pda);
    ~Callback() {};
  };
public:
  template<class U> Callback_t<RET, RArgs...>* make(U* owner, RET(U::*func)(RArgs...));
  template<class U, class... CArgs> Callback_t<RET, RArgs...>* make(U* owner, RET(U::*func)(CArgs..., RArgs...), CArgs&... cargs);
};
template<class RET2, class... RArgs2> template<class T2, class... CArgs2> CallbackFactory<RET2, RArgs2...>::Callback<T2, CArgs2...>::Callback(T2* t, RET2(T2::*x)(CArgs2..., RArgs2...), CArgs2... pda) : x(x), owner(t), cargs(std::forward<CArgs2>(pda)...) {}
template<class RET, class... RArgs> template<class U> Callback_t<RET, RArgs...>* CallbackFactory<RET, RArgs...>::make(U* owner, RET(U::*func)(RArgs...)) {
  return new CallbackFactory<RET, RArgs...>::Callback<U>(owner, func);
}
template<class RET, class... RArgs> template<class U, class... CArgs> Callback_t<RET, RArgs...>* CallbackFactory<RET, RArgs...>::make(U* owner, RET(U::*func)(CArgs..., RArgs...), CArgs&... cargs) {
  return new CallbackFactory<RET, RArgs...>::Callback<U, CArgs...>(owner, func, std::forward<CArgs...>(cargs)...);
}

class container {
public:
  static void printFrom(container* c) { c->print(); };
  container(int data) : data(data) {};
  ~container() {};
  void print() { printf("%d\n", data); };
  void printTo(FILE* f) { fprintf(f, "%d\n", data); };
  void printWith(int arg) { printf("%d:%d\n", data, arg); };
  void printToWith(FILE* f, int arg) { fprintf(f, "%d:%d\n", data, arg); };
private:
  int data;
};

int main() {
  fprintf(stdout, "stdout test\n");
  container c1(1), c2(20);
  CallbackFactory<void, int> cbfi;
  CallbackFactory<void> cbf;
  Callback_t<void>* fp1 = cbf.make(&c1, &container::print);
  fp1->call();//1                                                                                                                                                                                                                                                      
  Callback_t<void>* fp2 = cbf.make(&c2, &container::printTo, stdout);
  fp2->call();//20                                                                                                                                                                                                                                                     
  Callback_t<void, int>* fp3 = cbfi.make(&c2, &container::printWith);
  fp3->call(15);//20:15                                                                                                                                                                                                                                                
  Callback_t<void, int>* fp4 = cbfi.make<container, FILE*>(&c2, &container::printToWith, stdout);
  fp4->call(200);//20:200                                                                                                                                                                                                                                              
}

И вывод компилятора:

$ g++ test.cpp -o test.o -c -Wall -Wno-reorder -Wno-unused -std=c++14 -g                                                                                                                                                          
test.cpp: In function ‘int main()’:                                                                                                                                                                                                                                    
test.cpp:60:96: error: no matching function for call to ‘CallbackFactory<void, int>::make(container*, void (container::*)(FILE*, int), _IO_FILE*&)’                                                                                                                    
   Callback_t<void, int>* fp4 = cbfi.make<container, FILE*>(&c2, &container::printToWith, stdout);                                                                                                                                                                     
                                                                                                ^                                                                                                                                                                      
test.cpp:25:48: note: candidate: template<class U> Callback_t<RET, RArgs ...>* CallbackFactory<RET, RArgs>::make(U*, RET (U::*)(RArgs ...)) [with U = U; RET = void; RArgs = {int}]                                                                                    
   template<class U> Callback_t<RET, RArgs...>* make(U* owner, RET(U::*func)(RArgs...));                                                                                                                                                                               
                                                ^                                                                                                                                                                                                                      
test.cpp:25:48: note:   template argument deduction/substitution failed:                                                                                                                                                                                               
test.cpp:60:96: error: wrong number of template arguments (2, should be 1)                                                                                                                                                                                             
   Callback_t<void, int>* fp4 = cbfi.make<container, FILE*>(&c2, &container::printToWith, stdout);                                                                                                                                                                     
                                                                                                ^                                                                                                                                                                      
test.cpp:26:64: note: candidate: template<class U, class ... CArgs> Callback_t<RET, RArgs ...>* CallbackFactory<RET, RArgs>::make(U*, RET (U::*)(CArgs ..., RArgs ...), CArgs& ...) [with U = U; CArgs = {CArgs ...}; RET = void; RArgs = {int}]                       
   template<class U, class... CArgs> Callback_t<RET, RArgs...>* make(U* owner, RET(U::*func)(CArgs..., RArgs...), CArgs&... cargs);                                                                                                                                    
                                                                ^                                                                                                                                                                                                      
test.cpp:26:64: note:   template argument deduction/substitution failed:                                                                                                                                                                                               
test.cpp:60:96: note:   mismatched types ‘int’ and ‘FILE* {aka _IO_FILE*}’                                                                                                                                                                                             
   Callback_t<void, int>* fp4 = cbfi.make<container, FILE*>(&c2, &container::printToWith, stdout);

1 Ответ

0 голосов
/ 05 октября 2019

Так что g ++ запутался в выводе типов шаблонов, даже с явными шаблонами. Кроме того, visualstudio / msbuild / windows хочет, чтобы ключевое слово typename находилось в странном месте, что убивает posix / gcc, поэтому я использую #ifdef _WIN32. Полный рабочий код с большим количеством тестов приведен здесь для дальнейшего использования. Я собираюсь назвать это бета-версией GPL.

#ifdef _WIN32
#define wintypename typename
#else
#define wintypename
#endif

template<class RET, class... RArgs> class Callback_t {
public:
    virtual RET call(RArgs... rargs) = 0;
    virtual ~Callback_t() = default;
};

template<class RET, class... RArgs> class CallbackFactory {
private:
    template<class T, class... CArgs> class Callback : public Callback_t<RET, RArgs...> {
    private:
        T * owner;//TODO weak pointer?
        RET(T::*x)(CArgs..., RArgs...);
        std::tuple<CArgs...> cargs;
        RET call(RArgs... rargs) {
            return (*owner.*(x))(std::get<CArgs>(cargs)..., rargs...);
        };
    public:
        Callback(T* t, RET(T::*x)(CArgs..., RArgs...), CArgs... pda);
        ~Callback() {};
    };
public:
    template<class U, class... CArgs> static Callback_t<RET, RArgs...>* make(U* owner, CArgs... cargs, RET(U::*func)(CArgs..., RArgs...));
};
template<class RET2, class... RArgs2> template<class T2, class... CArgs2> CallbackFactory<RET2, RArgs2...>::Callback<T2, CArgs2...>::Callback(T2* t, RET2(T2::*x)(CArgs2..., RArgs2...), CArgs2... pda) : x(x), owner(t), cargs(std::forward<CArgs2>(pda)...) {}
template<class RET, class... RArgs> template<class U, class... CArgs> Callback_t<RET, RArgs...>* CallbackFactory<RET, RArgs...>::make(U* owner, CArgs... cargs, RET(U::*func)(CArgs..., RArgs...)) {
    return new wintypename CallbackFactory<RET, RArgs...>::Callback<U, CArgs...>(owner, func, std::forward<CArgs>(cargs)...);
}

class container {
public:
    static void printFrom(container* c) { c->print(); };
    container(int data) : data(data) {};
    ~container() {};
    void print() { printf("%d\n", data); };
    void printTo(FILE* f) { fprintf(f, "%d\n", data); };
    void printWith(int arg) { printf("%d:%d\n", data, arg); };
    void printToWith(FILE* f, int arg) { fprintf(f, "%d:%d\n", data, arg); };
    int print3AndSum(FILE* f, int a, int b) { fprintf(f, "%d:%d:%d\n", data, a, b); return a + b + data; };
private:
    int data;
};

int main() {
    fprintf(stdout, "stdout test\n");
    container c1(1), c2(20);
    Callback_t<void>* fp1 = CallbackFactory<void>::make(&c1, &container::print);
    fp1->call();//1
    Callback_t<void>* fp2 = CallbackFactory<void>::make<container, FILE*>(&c2, stdout, &container::printTo);
    fp2->call();//20
    Callback_t<void, int>* fp3 = CallbackFactory<void, int>::make(&c2, &container::printWith);
    fp3->call(15);//20:15
    Callback_t<void, int>* fp4 = CallbackFactory<void, int>::make<container, FILE*>(&c2, stdout, &container::printToWith);
    fp4->call(200);//20:200
    auto fp5 = CallbackFactory<void>::make<container, FILE*, int>(&c2, stdout, 70, &container::printToWith);
    fp5->call();//20:70
    auto fp6 = CallbackFactory<void, FILE*, int>::make(&c2, &container::printToWith);
    fp6->call(stdout, 128);//20:128
    auto fp7 = CallbackFactory<int, int>::make<container, FILE*, int>(&c2, stdout, 16, &container::print3AndSum);
    auto i = fp7->call(32);//20:16:32
    fp3->call(i);//20:68
}

Спасибо @Chipster за усилия и предложение, которые привели меня к переносу определений функций за пределы класса.

Редактировать: удален ненужный базовый шаблон

...