如何从可变参数宏正确调用可变参数模板函数？(How to correctly call a variadic template function from a variadic macro?)

 好的，首先，我将提供我正在问我的问题的代码。 
 
 EX_Factory.h 
 
#ifndef EX_FACTORY_H
#define EX_FACTORY_H

#include <string>
#include <map>
#include "Base.h"

struct EX_Factory{
    template<class U, typename... Args>
    static void registerC(const std::string &name){
        registry<Args...>[name] = &create<U>;
    }
    template<typename... Args>
    static Base * createObject(const std::string &key, Args... args){
        auto it = registry<Args...>.find(key);
        if(it == registry<Args...>.end()) return nullptr;
        return it->second(args...);
    }
    private:
        EX_Factory() = delete;
        template<typename... Args>
        static std::map<std::string, Base*(*)(Args...)> registry;

        template<class U, typename... Args>
        static Base* create(Args... args){
            return new U(args...);
        }
};

template<typename... Args>
std::map<std::string, Base*(*)(Args...)> EX_Factory::registry;

template<typename U, typename... Args>
struct MiddleMan{
    MiddleMan(const std::string &name){
        EX_Factory::registerC<U,Args...>(name);
    }
};
  #define REGISTER_MACRO(NAME, TYPE, ...)\ // Updated the macro here
    static MiddleMan<TYPE, ##__VA_ARGS__> mm_##TYPE(#NAME);

#endif
 
 上面的代码是我的Factory Design Pattern类的头文件。 它允许此类的用户为具有不同参数的Base类派生的对象注册构造函数。 
 
 好吧，快速解释为什么我使用__VA_ARGS__ vs ## __ VA_ARGS__，原因是，寄存器模板函数中的模板类型U总会至少有一个参数传递给宏。 
 
 我想要做的是构造一个预处理器宏 REGISTER_MACRO ，以在运行时之前注册派生类。 如何正确地从可变参数宏调用变量模板函数 ？ 
 
 测试或main.cpp 
 
#include "EX_Factory_1.h"
#include <iostream>

using namespace std;

struct derived_1 : public Base{
    derived_1(int i, int j, float f){
        cout << "Derived 1:\t" << i * j + f << endl;
    }
};
REGISTER_MACRO(name_1, derived_1, int,int,float);
struct derived_2 : public Base{
    derived_2(int i, int j){
        cout << "Derived 2:\t" << i + j << endl;
    }
};
REGISTER_MACRO(name_2, derived_2, int,int);

int main(){ // Program segfaults before entering main
    derived_1 * d_1 = static_cast<derived_1*>(EX_Factory::createObject<int, int, float>("name_1", 8, 8, 3.0));
    if(d_1 == nullptr) cout << "Why is it null?" << endl;
    else{
        delete d_1;
    }
    return 0;
}
 
 我在尝试编译上述代码时收到的错误： 请参阅下面的编辑 
 
In file included from test.cpp:1:0:
EX_Factory.h:39:38: error: expected constructor, destructor, or type conversion before ‘(’ token
    EX_Factory::registerC<__VA_ARGS__>(NAME);
                                      ^
test.cpp:11:1: note: in expansion of macro ‘REGISTER_MACRO’
 REGISTER_MACRO("derived_1",derived_1,int,int,float)
 ^~~~~~~~~~~~~~
EX_Factory.h:39:38: error: expected constructor, destructor, or type conversion before ‘(’ token
    EX_Factory::registerC<__VA_ARGS__>(NAME);
                                      ^
test.cpp:17:1: note: in expansion of macro ‘REGISTER_MACRO’
 REGISTER_MACRO("derived_2",derived_2,int,int)
 
 我使用的是g ++ 6.3编译器，因此默认情况下，它在Ubuntu 16.04环境中使用C ++ 14标准进行编译。 
 
 我找到的潜在解决方案，但不适合我的问题： 
 
 有没有办法定义可变参数模板宏 
 
 使用可变参数宏或模板来实现一组函数 
 
 潜在的解决方案但无法解释其解决方案： 
 
 如何使用variadic模板与variadic宏？ 我没有使用QT，而且我使用的是完全支持的C ++ 11编译器。 
 
 编辑 
 
 我现在知道为什么我的文件不会编译，但我不知道如何处理创建一个对象来为自己调用该方法。 我添加了一个中间人类，MiddleMan，并将静态registerC类的调用添加到其构造函数中，并修改了我的宏以创建对此类的静态引用。 这允许我的程序编译，但它使用此方法进行了段错误。 您现在将看到上面提到的反思。 
 
 在我对这个问题的回答中，我正在使用main.cpp测试这个类和宏。 

Alright, first things first, I will be providing the code I am asking my question for.
 
EX_Factory.h
 
#ifndef EX_FACTORY_H
#define EX_FACTORY_H

#include <string>
#include <map>
#include "Base.h"

struct EX_Factory{
    template<class U, typename... Args>
    static void registerC(const std::string &name){
        registry<Args...>[name] = &create<U>;
    }
    template<typename... Args>
    static Base * createObject(const std::string &key, Args... args){
        auto it = registry<Args...>.find(key);
        if(it == registry<Args...>.end()) return nullptr;
        return it->second(args...);
    }
    private:
        EX_Factory() = delete;
        template<typename... Args>
        static std::map<std::string, Base*(*)(Args...)> registry;

        template<class U, typename... Args>
        static Base* create(Args... args){
            return new U(args...);
        }
};

template<typename... Args>
std::map<std::string, Base*(*)(Args...)> EX_Factory::registry;

template<typename U, typename... Args>
struct MiddleMan{
    MiddleMan(const std::string &name){
        EX_Factory::registerC<U,Args...>(name);
    }
};
  #define REGISTER_MACRO(NAME, TYPE, ...)\ // Updated the macro here
    static MiddleMan<TYPE, ##__VA_ARGS__> mm_##TYPE(#NAME);

#endif
 
The code above is a header file for my Factory Design Pattern class. It allows the user of this class to register constructors for objects derived from the Base class with varying arguments.
 
Alright, quick explanation for why I am using __VA_ARGS__ vs ##__VA_ARGS__, the reason for this is, there will always be at least 1 argument, the template type U in the registerC template function, passed into the macro.
 
What I am trying to do is construct a preprocessor macro, REGISTER_MACRO , to register derived classes before runtime. How do I call a Variadic Template Function from a Variadic Macro correctly?
 
Tests or main.cpp
 
#include "EX_Factory_1.h"
#include <iostream>

using namespace std;

struct derived_1 : public Base{
    derived_1(int i, int j, float f){
        cout << "Derived 1:\t" << i * j + f << endl;
    }
};
REGISTER_MACRO(name_1, derived_1, int,int,float);
struct derived_2 : public Base{
    derived_2(int i, int j){
        cout << "Derived 2:\t" << i + j << endl;
    }
};
REGISTER_MACRO(name_2, derived_2, int,int);

int main(){ // Program segfaults before entering main
    derived_1 * d_1 = static_cast<derived_1*>(EX_Factory::createObject<int, int, float>("name_1", 8, 8, 3.0));
    if(d_1 == nullptr) cout << "Why is it null?" << endl;
    else{
        delete d_1;
    }
    return 0;
}
 
The errors I am receiving from trying to compile the above code: See Edit below
 
In file included from test.cpp:1:0:
EX_Factory.h:39:38: error: expected constructor, destructor, or type conversion before ‘(’ token
    EX_Factory::registerC<__VA_ARGS__>(NAME);
                                      ^
test.cpp:11:1: note: in expansion of macro ‘REGISTER_MACRO’
 REGISTER_MACRO("derived_1",derived_1,int,int,float)
 ^~~~~~~~~~~~~~
EX_Factory.h:39:38: error: expected constructor, destructor, or type conversion before ‘(’ token
    EX_Factory::registerC<__VA_ARGS__>(NAME);
                                      ^
test.cpp:17:1: note: in expansion of macro ‘REGISTER_MACRO’
 REGISTER_MACRO("derived_2",derived_2,int,int)
 
I am using the g++ 6.3 compiler, so by default, it compiles with C++14 standards in an Ubuntu 16.04 environment.
 
Potential solutions I've found, but don't fit my problem:
 
Is there a way to define variadic template macro
 
Using variadic macros or templates to implement a set of functions
 
Potential Solution but could not interpret its solution:
 
How to use variadic template with variadic macro ? I'm not using QT, and I am using a fully supported C++11 compiler.
 
Edit
 
I now know why my file will not compile, but I do not know how to handle creating an object to call the method for myself. I added a middle man class, MiddleMan, and added a call to the static registerC class to its constructor and modified my macro to create static references to this class. This allows my program to compile, but it segfaults with this method. You will see the mentioned reflections above now.
 
I am testing this class and macro out with my main.cpp in my answer to this question.

原文：https://stackoverflow.com/questions/43946698