C++ 如何使用可变模板解决此问题

我想写一个IoC/DI的东西。我目前提出了以下建议：

#ifndef IOC_H_INCLUDED
#define IOC_H_INCLUDED

#include <unordered_map>
#include <functional>
#include <typeinfo>
#include <string>

namespace IoC
{

    class Resolver
    {
    public:
        template <typename Itf, typename Class>
        void Register();

        template <typename Itf, typename Class, typename Arg1>
        void Register();

        template <typename T>
        T* Create();
    private:
        std::unordered_map<std::string,std::function<void*()>> m_creationFunctions;
    };

    template <typename Itf, typename Class>
    void Resolver::Register()
    {
        std::function<void*()> creator = [=](){ return new Class();};
        m_creationFunctions[std::string(typeid(Itf).name())]=creator;
    }

    template <typename Itf, typename Class, typename Arg1>
    void Resolver::Register()
    {
        std::function<void*()> creator = [=](){ return new Class(this->Create<Arg1>());};
        m_creationFunctions[std::string(typeid(Itf).name())]=creator;
    }

    template <typename T>
    T* Resolver::Create()
    {
        return nullptr;
    }
}

#endif // IOC_H_INCLUDED

#如果包括国际奥委会
#定义包含的IOC\u H\u
#包括
#包括
#包括
#包括
命名空间IoC
{
类解析器
{
公众：
模板
无效寄存器（）；
模板
无效寄存器（）；
模板
T*Create（）；
私人：
std：：无序映射m_创建函数；
};
模板
无效解析程序：：寄存器（）
{
std:：function creator=[=]（）{返回新类（）；}；
m_creationFunctions[std:：string（typeid（Itf）.name（））]=creator；
}
模板
无效解析程序：：寄存器（）
{
std:：function creator=[=]（）{返回新类（此->创建-在Windows上使用MingW编译和运行

（它应该可以工作-如果不能，请将其分离到IoC.h&main.cpp文件中，并删除include前面的//）
您的问题可以对尝试的内容进行一些澄清（例如，示例使用代码）。但这里有一个快速演示，介绍如何以可变的方式执行您的计划：

// in class definition
template <typename Itf, typename Class, typename ...Args>
void Register();

// in implementation section
template <typename Itf, typename Class, typename ...Args>
void Resolver::Register()
{
    std::function<void*()> creator = [=](){ return new Class(this->Create<Args>()...);};
    m_creationFunctions[std::string(typeid(Itf).name())]=creator;
}

//在类定义中
模板
无效寄存器（）；
//在执行科
模板
无效解析程序：：寄存器（）
{
std:：function creator=[=]（）{返回新类（this->Create（）…）；}；
m_creationFunctions[std:：string（typeid（Itf）.name（））]=creator；
}

我在VC++12上快速测试了以下内容，一切正常：

struct TestStruct {
  TestStruct(int * a, int * b, int * c) 
    : a_(a), b_(b), c_(c) {
  }
  int * a_;
  int * b_;
  int * c_;
};

// ...

IoC::Register testRegister;
testRegister.Register<int, TestStruct, int, int, int>();

struct TestStruct{
TestStruct（int*a、int*b、int*c）
：a_（a）、b_（b）、c_（c）{
}
int*a；
int*b_；
int*c_；
};
// ...
IoC：：寄存器testRegister；
testRegister.Register（）；

Create返回指针（因此TestStruct定义包含一堆指针）而不仅仅是类型，这有点奇怪，但我不知道这里的完整情况。
您的问题可能需要对尝试的内容进行一些澄清（例如，示例使用代码）但这里有一个快速演示，演示如何以可变的方式完成您所布置的工作：

// in class definition
template <typename Itf, typename Class, typename ...Args>
void Register();

// in implementation section
template <typename Itf, typename Class, typename ...Args>
void Resolver::Register()
{
    std::function<void*()> creator = [=](){ return new Class(this->Create<Args>()...);};
    m_creationFunctions[std::string(typeid(Itf).name())]=creator;
}

//在类定义中
模板
无效寄存器（）；
//在执行科
模板
无效解析程序：：寄存器（）
{
std:：function creator=[=]（）{返回新类（this->Create（）…）；}；
m_creationFunctions[std:：string（typeid（Itf）.name（））]=creator；
}

我在VC++12上快速测试了以下内容，一切正常：

struct TestStruct {
  TestStruct(int * a, int * b, int * c) 
    : a_(a), b_(b), c_(c) {
  }
  int * a_;
  int * b_;
  int * c_;
};

// ...

IoC::Register testRegister;
testRegister.Register<int, TestStruct, int, int, int>();

struct TestStruct{
TestStruct（int*a、int*b、int*c）
：a_（a）、b_（b）、c_（c）{
}
int*a；
int*b_；
int*c_；
};
// ...
IoC：：寄存器testRegister；
testRegister.Register（）；

Create返回指针（因此TestStruct定义包含一堆指针）而不仅仅是类型，这有点奇怪，但我不知道这里的完整情况。
您的问题可能需要对尝试的内容进行一些澄清（例如，示例使用代码）但这里有一个快速演示，演示如何以可变的方式完成您所布置的工作：

// in class definition
template <typename Itf, typename Class, typename ...Args>
void Register();

// in implementation section
template <typename Itf, typename Class, typename ...Args>
void Resolver::Register()
{
    std::function<void*()> creator = [=](){ return new Class(this->Create<Args>()...);};
    m_creationFunctions[std::string(typeid(Itf).name())]=creator;
}

//在类定义中
模板
无效寄存器（）；
//在执行科
模板
无效解析程序：：寄存器（）
{
std:：function creator=[=]（）{返回新类（this->Create（）…）；}；
m_creationFunctions[std:：string（typeid（Itf）.name（））]=creator；
}

我在VC++12上快速测试了以下内容，一切正常：

struct TestStruct {
  TestStruct(int * a, int * b, int * c) 
    : a_(a), b_(b), c_(c) {
  }
  int * a_;
  int * b_;
  int * c_;
};

// ...

IoC::Register testRegister;
testRegister.Register<int, TestStruct, int, int, int>();

struct TestStruct{
TestStruct（int*a、int*b、int*c）
：a_（a）、b_（b）、c_（c）{
}
int*a；
int*b_；
int*c_；
};
// ...
IoC：：寄存器testRegister；
testRegister.Register（）；

Create返回指针（因此TestStruct定义包含一堆指针）而不仅仅是类型，这有点奇怪，但我不知道这里的完整情况。
您的问题可能需要对尝试的内容进行一些澄清（例如，示例使用代码）但这里有一个快速演示，演示如何以可变的方式完成您所布置的工作：

// in class definition
template <typename Itf, typename Class, typename ...Args>
void Register();

// in implementation section
template <typename Itf, typename Class, typename ...Args>
void Resolver::Register()
{
    std::function<void*()> creator = [=](){ return new Class(this->Create<Args>()...);};
    m_creationFunctions[std::string(typeid(Itf).name())]=creator;
}

//在类定义中
模板
无效寄存器（）；
//在执行科
模板
无效解析程序：：寄存器（）
{
std:：function creator=[=]（）{返回新类（this->Create（）…）；}；
m_creationFunctions[std:：string（typeid（Itf）.name（））]=creator；
}

我在VC++12上快速测试了以下内容，一切正常：

struct TestStruct {
  TestStruct(int * a, int * b, int * c) 
    : a_(a), b_(b), c_(c) {
  }
  int * a_;
  int * b_;
  int * c_;
};

// ...

IoC::Register testRegister;
testRegister.Register<int, TestStruct, int, int, int>();

struct TestStruct{
TestStruct（int*a、int*b、int*c）
：a_（a）、b_（b）、c_（c）{
}
int*a；
int*b_；
int*c_；
};
// ...
IoC：：寄存器testRegister；
testRegister.Register（）；

Create返回指针有点奇怪（因此TestStruct定义包含一堆指针）不仅仅是类型，但我不知道这里的全貌。
您自己用可变模板试过吗？您能展示一下2参数版本的外观吗？从这里，将其推广到可变模板应该相当容易。什么是“IoC/DI东西”？IoC=控制反转/DI=依赖反转。基本上是一种基于接口的模式。它允许更容易的测试，因为对象的组成是使用寄存器调用配置的。通过这种方式，您可以将模拟对象注入到其他对象中。有关更多详细信息，我建议。对于.Net/Java，有几个好的框架（例如Autofac，Ninject）@dyp：是的，我试过了，但找不到正确的方法来做我想做的事（尽管看起来Sams answer可能会做我想做的事）.你自己用可变模板试过吗？你能展示一下2参数版本是什么样子吗？从那里，将它推广到可变模板应该相当容易。什么是“IoC/DI东西”？IoC=控制反转/DI=依赖反转。基本上是一种基于接口的模式。它允许更容易的测试，因为对象的组成是使用寄存器调用配置的。通过这种方式，您可以将模拟对象注入到其他对象中。有关更多详细信息，我建议。对于.Net/Java，有几个好的框架（例如Autofac，