C++ 派生类上的模板专门化

我不知道这是否可能，我检查了StackOverflow，我发现了很多东西，但没有任何东西真正符合我的问题（或者我看不出两者之间的关系）。 我想做的是这样的：

class Bean
{
    public:
    Bean(){}
virtual ~Bean(){}
    template <class T>
    bool set_(T){return false;}
    template <class T>
    bool get_(T&){return false;}
};
template <class T>
class GenericBean: public Bean
{
    protected:
    T type;
};
class Prova :  public GenericBean<int>
{
    public:
      Prova(){type = 0;}

   template<int> bool set_(int value){ type=value;}
   template<int> bool get_(int& value){value = type;}

};

类Bean
{
公众：
Bean（）{}
虚拟~Bean（）{}
模板
布尔集ut{return false；}
模板
bool get_uuT&{return false；}
};
模板
类GenericBean:publicbean
{
受保护的：
T型；
};
类Prova：公共泛型bean
{
公众：
Prova（）{type=0；}
模板布尔集合（int值）{type=value；}
模板bool get（int&value）{value=type；}
};

我想对Prova这样的对象进行转换，转换为Bean并获得专门的函数， 我想做的是这样的：

#include <vector>
#include "Bean.h"

using namespace std;
class VirtualMessage
{
public:
    VirtualMessage(void){}
    virtual ~VirtualMessage(void){} 

    template <class ReturnValue, class Item>
    bool Get(ReturnValue & val)
    {
            for(size_t i = 0; i < m_vData.size(); i++)
            {
                if(m_vData[i].get_<ReturnValue>(val))
                  return true;
            }
    }
    template <class Item, class Value>
    bool Set(Value val)
    {
         Item bean;
         if(bean.set_<Value>(val))
         {
           m_vData.push_back(bean);
           return true;
         }
         return false;
     }
protected:
     vector<Bean> m_vData;
};

#包括
#包括“Bean.h”
使用名称空间std；
类虚拟消息
{
公众：
虚拟消息（void）{}
虚拟~VirtualMessage（void）{}
模板
bool-Get（返回值和值）
{
对于（size_t i=0；i

主要内容：

#包括“VirtualMessage.h”
#包括“Bean.h”
int main（）
{
虚拟信息；
如果（消息集（4））
printf（“测试1通过”）；
}

这段代码不能编译

也许没人会用它，但我写了一些适合我需要的东西。它并不完美，我必须努力，但这是一个开始：

#define UNIQUE(T)   unsigned int GetID(){return UniqueType<T>::id();}

struct UniqueTypeBase 
{ 
   static unsigned int _ids; 
}; 

unsigned int UniqueTypeBase::_ids = 0; 
template <class T> 
struct UniqueType : public UniqueTypeBase 
{ 
   static const unsigned int id() 
   { 
      static unsigned int typeId = 0; 
      if (typeId == 0) 
         typeId = ++_ids; 
      return typeId; 
    } 
 }; 


template <class T>
class TemplateBean
{
  public:
     T m_tValue;
     template<class T> set_(T){return false;}
     template<class T> get_(T&){return false;}

     bool set_(T value){    m_tValue    =   value;      return true;}
     bool get_(T& value)    {   value       =   m_tValue;return true;}
};

class Prova :  public TemplateBean<int>
{
public:
    UNIQUE(Prova)
    Prova(){m_tValue = 0;}
};
class Prova2 :  public TemplateBean<float>
{
   public:
     UNIQUE(Prova2)
     Prova2(){m_tValue = 0;}
};


class VirtualMessage
{
  public:
    VirtualMessage(void){}
    virtual ~VirtualMessage(void){} 
    template <class Item, class ReturnValue>
      bool Get(ReturnValue & val)
    {
         Item a;
         map<unsigned int, void*>::iterator it;
         it = m_TagMap.find(a.GetID());
         if(it != m_TagMap.end())
         {
             Item*  pItem = reinterpret_cast<Item*>(it->second);
             if(pItem->get_(val))
                return true;
          }
          return false;
     }
    template <class Item, class Value>
     bool Set(Value val)
    {
      Item* pBean = new Item();
      if(pBean->set_(val))
      {
           m_TagMap[pBean->GetID()] = (void*)pBean;     
           return true;
      }
      return false;
  }
  protected:
    map<unsigned int, void*> m_TagMap;
 };

#定义唯一（T）无符号int-GetID（）{return UniqueType:：id（）；}
结构唯一类型库
{ 
静态无符号整数ID；
}; 
无符号int UniqueTypeBase:：_id=0；
模板
结构UniqueType：公共UniqueTypeBase
{ 
静态常量无符号整数id（）
{ 
静态无符号int-typeId=0；
if（typeId==0）
typeId=++\u id；
返回typeId；
} 
}; 
模板
类模板bean
{
公众：
T mu T价值；
模板集（T）{return false；}
模板获取（T&{return false；}
bool set_uT（value）{m_tValue=value；返回true；}
bool get（T&value）{value=m_tValue；返回true；}
};
类Prova：公共模板bean
{
公众：
独特（普罗瓦）
Prova（）{m_tValue=0；}
};
类Prova2：公共模板bean
{
公众：
唯一（Prova2）
Prova2（）{m_tValue=0；}
};
类虚拟消息
{
公众：
虚拟消息（void）{}
虚拟~VirtualMessage（void）{}
模板
bool-Get（返回值和值）
{
项目a；
对它进行迭代器；
it=m_TagMap.find（a.GetID（））；
if（it！=m_TagMap.end（））
{
项目*pItem=重新解释（它->第二次）；
if（pItem->get_val））
返回true；
}
返回false；
}
模板
布尔集合（值val）
{
Item*pBean=新项（）；
如果（pBean->set_val））
{
m_TagMap[pBean->GetID（）]=（void*）pBean；
返回true；
}
返回false；
}
受保护的：
地图m_TagMap；
};

测试干线：

 int main()
 {
    VirtualMessage msg;
    if(msg.Set<Prova ,int>(4))
        printf("Test 1 passed\n");
    if(!msg.Set<Prova,float>(4.00))
        printf("Test 2 succed\n");
    if(msg.Set<Prova2,float>(4.00))
        printf("Test 3 succed\n");
    int a=0;
    if(msg.Get<Prova>(a))
         printf("%d = 4...if 4=4 test passed\n",a);
     float b=0;
    if(msg.Get<Prova2>(b))
        printf("%f = 4...if 4=4 test passed\n",b);
    getchar();
  }

intmain（）
{
虚拟信息；
如果（消息集（4））
printf（“测试1通过\n”）；
如果（！msg.Set（4.00））
printf（“测试2成功\n”）；
如果（消息集（4.00））
printf（“测试3成功\n”）；
int a=0；
if（msg.Get（a））
printf（“%d=4…如果4=4测试通过\n”，a）；
浮动b=0；
if（msg.Get（b））
printf（“%f=4…如果4=4测试通过\n”，b）；
getchar（）；
}

我认为您误解了模板的使用

模板是构建类或方法的蓝图，编译器使用模板生成真实的类和方法（称为实例化）

因此，它们纯粹是一种编译时工具。因此，它们不能是虚拟的，因此在派生类中重载模板方法并不意味着您所期望的。当从派生类（静态）使用基类方法时，它隐藏基类方法，但如果使用基类的引用或指针，则仍然调用基类方法

不幸的是，您试图实现的目标对于模板来说是不可能的：它需要运行时检查

此外，您使用的是一个

std:：vector

，它将无法正常工作。多态类型不应被C++中的值所操控，需要一个<代码> STD:：vector <代码>或<代码> Booo:：pTrvector向量 >…/P>

---

我建议在尝试你自己设定的任务之前先读一个好的C++底漆。你需要一个C++范式的基本介绍…还有戈查斯。还有很多问题。

我想你误解了模板的使用

模板是构建类或方法的蓝图，编译器使用模板生成真实的类和方法（称为实例化）

因此，它们纯粹是一种编译时工具。因此，它们不能是虚拟的，因此在派生类中重载模板方法并不意味着您所期望的。当从派生类（静态）使用基类方法时，它隐藏基类方法，但如果使用基类的引用或指针，则仍然调用基类方法

不幸的是，您试图实现的目标对于模板来说是不可能的：它需要运行时检查

此外，您使用的是一个

std:：vector

，它将无法正常工作。多态类型不应被C++中的值所操控，需要一个<代码> STD:：vector <代码>或<代码> Booo:：pTrvector向量 >…/P> 我建议在尝试你自己设定的任务之前先读一个好的C++底漆。你需要一个C++范式的基本介绍…还有戈查斯。还有很多陷阱。

Remar

 int main()
 {
    VirtualMessage msg;
    if(msg.Set<Prova ,int>(4))
        printf("Test 1 passed\n");
    if(!msg.Set<Prova,float>(4.00))
        printf("Test 2 succed\n");
    if(msg.Set<Prova2,float>(4.00))
        printf("Test 3 succed\n");
    int a=0;
    if(msg.Get<Prova>(a))
         printf("%d = 4...if 4=4 test passed\n",a);
     float b=0;
    if(msg.Get<Prova2>(b))
        printf("%f = 4...if 4=4 test passed\n",b);
    getchar();
  }