从基指针向下转换为模板派生类型 [英] Downcasting from base pointer to templated derived types

问题描述

我有以下层次结构：

  class base 
 {
 public：
 virtual〜base（）{} 
 virtual void foo（）{} 
}; 
 
 template< typename T> 
 class derived1：public base 
 {
 virtual void foo（）{}; 
}; 
 
 template< typename T> 
 class derived2：public base 
 {
 virtual void foo（）{}; 
}; 
  

现在给一个指向base的指针，我想知道
是derived1或derived2。问题是，
两者derived1和derived2可以专门用于许多不同的
类型，使用dynamic_cast测试下降演算需要
模板类型知道。我结束了乱七八糟的，不可思议的和不完整的代码：

  base * b = new derived1< int& ; 
 
 if（dynamic_cast< derived1< int> *> || 
 dynamic_cast< derived1< unsigned int> *> || 
 dynamic_cast< derived1< double& ）
 std :: cout<< is derived1; 
 else if（dynamic_cast< derived2< int> *> || 
 dynamic_cast< derived2< unsigned int> * || 
 dynamic_cast< derived2&Double; *> $ b std :: cout<< is derived2;有没有更好的方法，可以处理任何类型的专业化？
 
 

代替：

  if（dynamic_cast< derived1< int> *（b）|| 
 dynamic_cast< derived1< unsigned int> *> ;（b）|| 
 dynamic_cast< derived1< double> *（b））
 std :: cout< is derived1; 
 else if（dynamic_cast< derived2< int>（b）|| 
 dynamic_cast< derived2< unsigned int> *>（b）|| 
 dynamic_cast< derived2& *>（b））
 std :: cout<< is derived2; 
  

添加 virtual print_name（）const 到 base ，然后执行：

  b $ b std :: unique_ptr< base> b（new derived1< int>（））; 
 b-> print_name（）; 
} 
 class base 
 {
 public：
〜base（）{} 
 virtual void foo（）{} 
 virtual void print_name （）const = 0; 
}; 
 
 template< typename T> 
 class derived1：public base 
 {
 virtual void foo（）{} 
 virtual void print_name（）const {
 std :: cout< is derived1; 
} 
}; 
 
 template< typename T> 
 class derived2：public base 
 {
 virtual void foo（）{} 
 virtual void print_name（）const {
 std :: cout< is derived2; 
} 
}; 
  

I have the following hierarchy:

class base
{
public:
   virtual ~base(){}
   virtual void foo() {}
};

template <typename T>
class derived1 : public base
{
   virtual void foo() {};
};

template <typename T>
class derived2 : public base
{
   virtual void foo() {};
};

Now given a pointer to base, I'd like to find out if the underlying is either derived1 or derived2. The problem is that both derived1 and derived2 can be specialised on many different types, using dynamic_cast to test for a down cast requires the template type to be know. I've ended up with messy, unmaintable and incomplete bit of code:

base* b = new derived1<int>();

if (dynamic_cast<derived1<int>*> ||
    dynamic_cast<derived1<unsigned int>*> ||
    dynamic_cast<derived1<double>*>)
  std::cout << "is derived1";
else if (dynamic_cast<derived2<int>*> ||
    dynamic_cast<derived2<unsigned int>*> ||
    dynamic_cast<derived2<double>*>)
  std::cout << "is derived2";

Is there a better way, that can handle any type specialization?

解决方案

Move the logic which depends on the type into the type.

Instead of:

if (dynamic_cast<derived1<int>*>(b) ||
    dynamic_cast<derived1<unsigned int>*>(b) ||
    dynamic_cast<derived1<double>*>(b))
  std::cout << "is derived1";
else if (dynamic_cast<derived2<int>*>(b) ||
    dynamic_cast<derived2<unsigned int>*>(b) ||
    dynamic_cast<derived2<double>*>(b))
  std::cout << "is derived2";

add a virtual print_name() const function to base, and then do:

void example() {
    std::unique_ptr<base> b(new derived1<int>());
    b->print_name();
}
class base
{
public:
   ~base(){}
   virtual void foo() {}
   virtual void print_name() const = 0;
};

template <typename T>
class derived1 : public base
{
   virtual void foo() {}
   virtual void print_name() const {
       std::cout << "is derived1";
   }
};

template <typename T>
class derived2 : public base
{
   virtual void foo() {}
   virtual void print_name() const {
       std::cout << "is derived2";
   }
};

这篇关于从基指针向下转换为模板派生类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！