C++ C++；如何扩展模板以使用向量<；T>；

不幸的是，我的实际模板中充满了与我的问题无关的东西，所以我尝试将所有内容都放在一个简短的示例中。比方说，我已经编写了以下模板：

#include <vector>
template <typename T> class MyTemplate{
  public:
    typedef void(*MyFunc)(T);
    void addFunc(MyFunc f){myFuncs.push_back(f);}
    void callFuncs(T value){
        for (std::size_t i=0;i<myFuncs.size();i++){myFuncs[i](value);}
    }
  private:
    std::vector<MyFunc> myFuncs;
};

但是，以下内容毫无意义：

template <typename T> MyTemplate<std::vector<T> > : public MyTemplate<std::vector<T> >

模板MyTemplate:公共MyTemplate

但在某种意义上，这就是我想要的

我很抱歉这么长的帖子，我希望这或多或少是清楚的什么是我的问题

编辑：我刚刚在上面的代码中发现了一个错误。向量模板中的循环应为

for (std::size_t i=0;i<mySingleElementFuncs.size();i++){
    for (int size_t j=0;j<value.size();j++){
        mySingleElemetnFuncs[i](value[j]);
    }
}

用于（std:：size\u t i=0；i
模板
类MyTemplateBase{
//通用的东西在这里
};
模板
类MyTemplate:公共MyTemplateBase{
//这里什么都没有
};
模板
类MyTemplate:公共MyTemplateBase{
//这里有专门的东西
}

如果不希望公共继承，可以使用私有继承，但必须显式导出私有继承的所有内容：

template <typename T> 
class MyTemplate<std::vector<T>> : private MyTemplateBase <std::vector<T>> {
 public:
  // generic stuff re-exported
  using MyTemplateBase<std::vector<T>>::Func1;
  using MyTemplateBase<std::vector<T>>::Func2;
  // specialized stuff goes here
}

模板
类MyTemplate:私有MyTemplateBase{
公众：
//转口非专利物品
使用MyTemplateBase:：Func1；
使用MyTemplateBase:：Func2；
//这里有专门的东西
}

可能仍然值得，因为公共继承并不是最适合代码重用的工具。
事实上，您希望向专门化添加功能，例如：

template <typename T> class MyTemplate<std::vector<T> >
{
public:
   typedef void(*MySingleElementFunc)(T);
   typedef void(*MyVectorFunc)(std::vector<T>);

   void addSingleElementFunc(MyVectorFuncf){
       this->myVcetorFuncs.push_back(f);
   }

   void addSingleElementFunc(MySingleElementFunc f){
       this->mySingleElementFuncs.push_back(f);
   }

   void callFuncs(const std::vector<T>& value){
       for (std::size_t i=0;i<myVectorFuncs.size();i++){
           myVectorFuncs[i](value);
       }
       for (std::size_t i=0;i<mySingleElementFuncs.size();i++){
           for (int size_t i=0;i<value.size();i++){
                mySingleElemetnFuncs[i](value[i]);
           }
       }
   }       
   private:
       std::vector<MySingleElementFunc> mySingleElementFuncs;
       std::vector<MyVectorFunc> myVectorFuncs;
};

template<template <typename ...> class T /*= std::vector*/>
class SomeClass
{
    T x;
};

模板类MyTemplate
{
公众：
typedef void（*MySingleElementFunc）（T）；
typedef void（*MyVectorFunc）（标准：：向量）；
void addSingleElementFunc（MyVectorFuncf）{
这->myVcetorFuncs.向后推（f）；
}
void addSingleElementFunc（MySingleElementFunc f）{
此->mySingleElementFuncs.向后推（f）；
}
void callFuncs（常量std:：向量和值）{
对于（std:：size_t i=0；i我认为，由于Vector是一个模板而不是一个类，所以应该类似于：

template <typename T> class MyTemplate<std::vector<T> >
{
public:
   typedef void(*MySingleElementFunc)(T);
   typedef void(*MyVectorFunc)(std::vector<T>);

   void addSingleElementFunc(MyVectorFuncf){
       this->myVcetorFuncs.push_back(f);
   }

   void addSingleElementFunc(MySingleElementFunc f){
       this->mySingleElementFuncs.push_back(f);
   }

   void callFuncs(const std::vector<T>& value){
       for (std::size_t i=0;i<myVectorFuncs.size();i++){
           myVectorFuncs[i](value);
       }
       for (std::size_t i=0;i<mySingleElementFuncs.size();i++){
           for (int size_t i=0;i<value.size();i++){
                mySingleElemetnFuncs[i](value[i]);
           }
       }
   }       
   private:
       std::vector<MySingleElementFunc> mySingleElementFuncs;
       std::vector<MyVectorFunc> myVectorFuncs;
};

template<template <typename ...> class T /*= std::vector*/>
class SomeClass
{
    T x;
};

模板
上课
{
tx；
};
我真的不明白这是如何解决我的问题的。也许这也是因为我在陈述问题时不是很清楚；）。但是，在您的上一个代码段中，Func1和Func2属于同一类型。“这是如何解决我的问题的”。通过提供两个版本的
MyTemplate
，一个扩展用于向量，一个基本用于其他所有内容，而无需重复代码。“Func1和Func2属于同一类型”。是的，这有什么关系？它们只是示例。我试着实现我想做的事情（添加函数并调用它们）按照您建议的方式。我在MyTemplate>template中使用另一种方法添加函数时遇到问题。似乎我无法在已经存在addFunc（void（*f）（vector）的情况下添加addFunc（void（*f）（T））。你能评论一下如何处理这个问题吗？我确实试过了，但是我没有得到一个你提出的继承方案的运行示例。如果你想重载继承的
addThis
函数，你必须显式地将它引入范围，比如：
使用MyTemplateBase:：addFunc；
参见例如……是的，使用……使它工作：）。（即使是公共继承，我也不得不把“使用…”放在上面）实际上我也在考虑这样做。在我的原始帖子中，你可以看到我已经开始把一些代码放在向量专用模板中（注释的部分）。我不喜欢这个解决方案的地方是，我将不得不编写重复的代码。向量专门化与非专门化模板的共同点必须再次出现在专门化版本中。因此…+1因为它解决了问题，-1因为我不相信这是“最优雅的方式”，再加上+1，因为“最优雅”太主观了；）
template <typename T> 
class MyTemplate<std::vector<T>> : private MyTemplateBase <std::vector<T>> {
 public:
  // generic stuff re-exported
  using MyTemplateBase<std::vector<T>>::Func1;
  using MyTemplateBase<std::vector<T>>::Func2;
  // specialized stuff goes here
}

template <typename T> class MyTemplate<std::vector<T> >
{
public:
   typedef void(*MySingleElementFunc)(T);
   typedef void(*MyVectorFunc)(std::vector<T>);

   void addSingleElementFunc(MyVectorFuncf){
       this->myVcetorFuncs.push_back(f);
   }

   void addSingleElementFunc(MySingleElementFunc f){
       this->mySingleElementFuncs.push_back(f);
   }

   void callFuncs(const std::vector<T>& value){
       for (std::size_t i=0;i<myVectorFuncs.size();i++){
           myVectorFuncs[i](value);
       }
       for (std::size_t i=0;i<mySingleElementFuncs.size();i++){
           for (int size_t i=0;i<value.size();i++){
                mySingleElemetnFuncs[i](value[i]);
           }
       }
   }       
   private:
       std::vector<MySingleElementFunc> mySingleElementFuncs;
       std::vector<MyVectorFunc> myVectorFuncs;
};

template<template <typename ...> class T /*= std::vector*/>
class SomeClass
{
    T x;
};