从模板参数中检索基类型

Retrieving the base type(s) from a template parameter

本文关键字：检索 基类 类型 参数      更新时间：2023-10-16

是否有可能以某种方式获得某个类的基，以便它可以像这样通过模板链传递(伪代码)

template<typename base>
class first
{
    template_taking_base<base>* member;
}
template<typename derived>
class second: public first< function_giving_me_base_of_derived >
{
    derived* get( string s ) { dynamic_cast<derived>( member->get_base( s ) ); }
}

为了避免

template<typename base, typename derived>
class second: public first<base>
{
  //...
}

为什么这是必要的?

我有两种不同类型的资源，那些在主存，那些在gpu内存，目前这看起来像:

         basic_resource
         /           
        /             
   cpu_resource   gpu_resource
       |               |
   many_derived    many_derived

我也有这些资源的句柄。这个想法是，你会有

handle<image> someimage("blah.bmp")
image the_image = someimage.get();

get函数请求缓存获取资源。缓存返回cpu_resource或gpu_resource，而句柄动态地将其强制转换为模板化的资源(在上面的例子中)。

Cache本身就是一个模板

template<typename resource_base>
class cache
{
public:
//...
   resource_base* get_resource( string name )
private:
//...
}

其中resource base应为cpu_resource或gpu_resource之一，并在缓存模板的各种成员函数中进行适当的专门化。

所以句柄，保持一个指向缓存的指针，必须知道资源的基本类型。

专门

template<typename resource_type>
class handle
{
  string name;
  cache< /*need the base of resource_type here*/ >* cache
  resource_type* get( void ) { dynamic_cast<resource_type>( cache->get( name ) ); }
}

我试着概括这个问题，这样我就可以更快地得到答案，但这不起作用，所以也许这将。

任何派生的类都已经是base类型，那么为什么要这样做呢?

如果你必须，你可以这样做

class A
{   
public:
    A()
    {
    }
};
class ADer : public A
{
public:
    typedef A base_t;
};
class B
{
public:
    B()
    {
    }
};
class BDer : public B
{
public:
    typedef B base_t;
};
template <typename T>
void Foo()
{
    typename T::base_t x;
    // Here x will always be base class of T
}

int main()
{
    Foo<BDer>();
    Foo<ADer>();
    return 0;
}
相关文章：