C++ 模板化成员函数调用g++；错误：没有用于调用的匹配函数

g++在该示例上遇到错误

我有一个类

选项

，它包含一个

std:：string

OptionValue

继承自

Option

，具有模板类型和键的类型为

std:：string

的模板参数

OptionManager

manage

OptionValue

在

std:：map

选项管理器

具有成员功能

创建

：

  template <typename T, std::string & key>
  void  create(const T & value);

OptionValue.hpp

class                                   Option
{
public:
  Option(std::string & key) :
  key_(key)
  {}

  virtual ~Option()
  {}

 protected:
   std::string                           key_;
 };

template                                <typename T, std::string & key>
class                                   OptionValue : public Option
{
public:
  OptionValue<T, key>(T val) :
  Option(key),
  val_(val)
  {}

  virtual ~OptionValue()
  {}

private:
  T                                     val_;
};

class                                   OptionManager
{
public:
  OptionManager(){}
  ~OptionManager(){}
  template                              <typename T, std::string & key>
  void                                  create(const T & value)
  {
    Option                              *tmp;

    tmp = new OptionValue<T, key>(value);
    this->list_.insert(t_pair(key, tmp));
  }
private:
  std::map<std::string, Option*>                        list_;
  typedef std::map<std::string, Option*>::iterator      t_iter;
  typedef std::pair<std::string, Option*>               t_pair;

int                             main()
{
  OptionManager                 *manager;

  manager = new OptionManager;
  manager->create<int, "my_key">(3);
  return 0;
}

模板
类别选项值：公共选项
{
公众：
期权价值（T val）：
选项（键），
瓦尔（瓦尔）
{}
虚拟~OptionValue（）
{}
私人：
T瓦卢；
};

OptionManager.hpp

class                                   Option
{
public:
  Option(std::string & key) :
  key_(key)
  {}

  virtual ~Option()
  {}

 protected:
   std::string                           key_;
 };

template                                <typename T, std::string & key>
class                                   OptionValue : public Option
{
public:
  OptionValue<T, key>(T val) :
  Option(key),
  val_(val)
  {}

  virtual ~OptionValue()
  {}

private:
  T                                     val_;
};

class                                   OptionManager
{
public:
  OptionManager(){}
  ~OptionManager(){}
  template                              <typename T, std::string & key>
  void                                  create(const T & value)
  {
    Option                              *tmp;

    tmp = new OptionValue<T, key>(value);
    this->list_.insert(t_pair(key, tmp));
  }
private:
  std::map<std::string, Option*>                        list_;
  typedef std::map<std::string, Option*>::iterator      t_iter;
  typedef std::pair<std::string, Option*>               t_pair;

int                             main()
{
  OptionManager                 *manager;

  manager = new OptionManager;
  manager->create<int, "my_key">(3);
  return 0;
}

类选项管理器
{
公众：
OptionManager（）{}
~OptionManager（）{}
模板
无效创建（常量T和值）
{
选项*tmp；
tmp=新期权价值（价值）；
此->列表插入（t_对（键，tmp））；
}
私人：
std：：地图列表；
typedef std:：map:：迭代器t_iter；
typedef std：：对t_对；

})

main.cpp

class                                   Option
{
public:
  Option(std::string & key) :
  key_(key)
  {}

  virtual ~Option()
  {}

 protected:
   std::string                           key_;
 };

template                                <typename T, std::string & key>
class                                   OptionValue : public Option
{
public:
  OptionValue<T, key>(T val) :
  Option(key),
  val_(val)
  {}

  virtual ~OptionValue()
  {}

private:
  T                                     val_;
};

class                                   OptionManager
{
public:
  OptionManager(){}
  ~OptionManager(){}
  template                              <typename T, std::string & key>
  void                                  create(const T & value)
  {
    Option                              *tmp;

    tmp = new OptionValue<T, key>(value);
    this->list_.insert(t_pair(key, tmp));
  }
private:
  std::map<std::string, Option*>                        list_;
  typedef std::map<std::string, Option*>::iterator      t_iter;
  typedef std::pair<std::string, Option*>               t_pair;

int                             main()
{
  OptionManager                 *manager;

  manager = new OptionManager;
  manager->create<int, "my_key">(3);
  return 0;
}

intmain（）
{
选项管理器*管理器；
经理=新选项经理；
经理->创建（3）；
返回0；
}

g++错误

main.cpp: In function ‘int main()’:
main.cpp:8:35: error: no matching function for call to ‘OptionManager::create(int)’
main.cpp:8:35: note: candidate is:
OptionManager.hpp:14:12: note: template<class T, std::string& key> void OptionManager::create(const T&)

main.cpp:在函数“int main（）”中：
main.cpp:8:35:错误：对“OptionManager:：create（int）”的调用没有匹配的函数
main.cpp:8:35：注：候选人为：
OptionManager.hpp:14:12:注意：模板void OptionManager:：create（const T&）

第二个模板参数的类型为

std:：string&

。您不能用临时对象初始化它（在您的例子中，是通过将字符串文本转换为

std:：string

）创建的对象）。

这是我多年来看到的最原始的代码格式。太可怕了，坦克！你帮了我很多忙！