Question

是否有可能以某种方式获取某个类的基础，以便它可以像这样传递给模板链（伪代码）

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，而句柄动态将其转换为模板化资源（在上面的案例图像中）。

缓存本身就是一个模板

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

其中资源库应该是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 ) ); }
}

我试图将这个问题概括一下，这样我就可以更快地得到一个答案，但这样做不行，所以也许会这样。如果您需要更多细节，请询问。

Answer 1

任何派生的类已经是 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;
}

从模板参数中检索基本类型

1 个答案: