Question

我不知道是否可能，我检查了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;}

};

我想拥有像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;
};

主：

#include "VirtualMessage.h"
#include "Bean.h"
int main()
{
    VirtualMessage msg;
    if(msg.Set<Prova ,int>(4))
        printf("Test 1 passed");
}

此代码无法编译

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

#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;
 };

测试主要：

 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();
  }

Answer 1

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

模板是 blueprints 来构建类或方法，编译器使用它来生成真正的类和方法（称为实例化）。

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

遗憾的是，您尝试实现的模板无法实现：它需要运行时检查。

此外，您使用的std::vector<Bean>无法正常使用。多态类型不应由C ++中的值操纵，您需要std::vector< std::unique_ptr<Bean> >或boost::ptr_vector<Bean> ......

我建议您在尝试自己设定的任务之前先阅读一篇优秀的C ++入门书。您需要对C ++范例的基本介绍......以及陷阱。并且有很多陷阱。

派生类的模板专精

1 个答案: