Question

我遇到了模板专业化的问题，因为我不想重新定义方法，我想使用通用方法。

template<class VarsContainer, class Specific>
class State
{
public:
  State();
  ~State(){}

  HSError_t Update(LoggerData const &lData);
  VarsContainer state;

  void swap(State &rhs);
  State & operator=(State rhs); // pass by value copy

protected:
  void UpdateSpecific(Specific *rhs);
  Specific specificPtr;
};

在实施中，我执行以下操作：

template<class VarsContainer, class Specific>
HSError_t State<VarsContainer, Specific>::Update(LoggerData const &lData)
{
  HSError_t error_t = HeatInterfaceError;
  specificPtr = const_cast<Specific>(&lData);
  error_t = UpdateSpecific(specificPtr);
  if(error_t != HeatSuccess)
  {
    return error_t;
  }
  return error_t;
}

template<class VarsContainer, class Specific>
HSError_t State<VarsContainer, Specific>::UpdateSpecific(Specific *rhs)
{
  HSError_t error_t = HeatInterfaceError;
  return error_t;
}

完成后，我按以下方式专门化模板：

template<>
class State<ChemicalVars, Chemicals*>
{
public:
  ChemicalVars state;

protected:
  HSError_t UpdateSpecific(Chemicals *chemicals);
  Chemicals *specificPtr;
};

我在cpp文件中定义UpdateSpecific，将数据从专用结构复制到本地状态。

问题是，当我尝试调用“Update”方法时，编译器没有在我的ChemicalVars专用模板中为它创建定义。

之后我改变了我的专业化：

template<>
class State<ChemicalVars, Chemicals*>
{
public:
  ChemicalVars state;
  HSError_t Update(LoggerData const &lData);

protected:
  HSError_t UpdateSpecific(Chemicals *chemicals);
  Chemicals *specificPtr;
};

但是，错误是一样的：

undefined reference to `State<ChemicalVars, Chemicals*>::Update(LoggerData const&)'

问题是通用实现是好的，我只想使用通用状态中定义的专业化使用的实现。

Answer 1

专业化和基本模板的定义在某种程度上是无关的。专门化不会从基础模板继承任何内容，您必须重新定义所需的基本模板中的所有函数。

常见的解决方法是将基本模板拆分为一个基类，该基类具有所有特化所共有的所有代码，然后从基础模板和特化中继承，以便可以重用公共代码。 / p>

Answer 2

专门化一个类模板意味着每当使用该特定专用类型实例化该类时，它将使用专用定义。这就是你得到第一个未定义错误的原因。但是当你添加了专门的更新函数但没有定义它，而是假设它使用默认值时，那会导致你得到的第二条错误信息，因为它没有按照你的意愿使用默认值，而是试图寻找专门的更新定义。我认为你想要的东西更像一点抽象：

//This will hold all function common to template param for State class
template<typename Container, typename Specific>
struct CommonStateDefinition{  
     void Update(StructData const &lData){
         std::cout<<"In CommonStateDefinition::Update" << endl;
     }
};

template<typename Container, typename Specific>
struct State{
    CommonStateDefinition<Container,Specific> m_stateImpl;
    void Update(StructData const &lData){
        std::cout << "In State::Update" << endl;
        m_stateImpl.Update(lData);
    }
}

template<>
class State<ChemicalVars, Chemicals*>{
    CommonStateDefinition<ChemicalVars,Chemicals*> m_stateImpl;
    //use the common update via delegation
    void Update(StructData const &lData){
        std::cout << "In State<ChemicalVars,Chemicals*>::Update" << endl;
        m_stateImpl.Update(lData);
    }
    //add other specialized function
}

如何避免在模板特化中重新定义类方法？

2 个答案: