1

这是我的情况：

基类，无模板类型：

struct Thing
{

} ;

模板类，扩展了那个基类

template <typename T> struct VertexWriter : public Thing
{ 
    template <typename S>
    bool intersects( S* otherThing )
    {
        // has a body, returns T or F
    }
} ;

派生类，CONCRETE 类型（无模板）

struct Rocket : VertexWriter<VertexPNCT>
{
    template <typename S>
    bool intersects( S* otherThing ) ; // WANTS TO OVERRIDE
    // implementation in VertexWriter<T>
} ;

但template typename<S> bool VertexWriter<T>::intersects不能标记为virtual，因为它是一个模板类。

有许多类派生自VertexWriter<VertexPNCT>特化，因此模板特化VertexWriter<VertexPNCT>不起作用。

所以正常的做法是提供模板特化。

但是Rocket指定它是一个VertexWriter<VertexPNCT>，所以它不再是一个模板类。intersects它可以像虚拟功能一样专门化或覆盖吗？

4

3 回答 3

1

不，正如您所说，您不能使用虚拟函数，它会提供运行时多态性。

也就是说，根据您在更改课程布局方面的余地，您也许可以使用 CRTP 做一些事情。

template <typename T, typename Derived> struct VertexWriter : public Thing
{ 
    template <typename S>
    bool intersects( S* otherThing )
    {
        return static_cast<Derived*>(this)->insersects_impl(otherThing);
    }

    template<typename S>
    bool insersects_impl( S* otherThing)
    {
         // Whatever
    }
} ;

struct Rocket : VertexWriter<VertexPNCT, Rocket>
{
   template <typename S>
   bool intersects_impl( S* otherThing ) { ... } // WANTS TO OVERRIDE
                       // implementation in VertexWriter<T>
} ;

intersects简单转发到 CRTP 函数的基本实现。如果派生类覆盖它，它将使用覆盖，否则它将回退到默认值。请注意，这确实使您的类层次结构复杂化，但可能会完成您正在寻找的内容。

于 2013-01-24T19:45:31.517 回答
0

你不能。

模板化的成员函数不能是虚拟的。

VertexWriter 是模板化的、专用的还是普通的类都没有关系。

于 2013-01-24T19:36:56.927 回答
0

您可以在该类模板VertexWriter上进行模板化S并创建一个虚函数intersects

template <typename T, typename S> struct VertexWriter : public Thing
{ 
    virtual bool intersects( S* otherThing )
    {
        // has a body, returns T or F
    }
} ;

现在您可以intersects在派生类中覆盖

template<typename S>
struct Rocket : VertexWriter<VertexPNCT, S>
{
    virtual bool intersects( S* otherThing ) ; // WANTS TO OVERRIDE
    // implementation in VertexWriter<T>
}
于 2013-01-24T19:48:02.433 回答