Question

我正在使用一些具有破坏多态性的生成类。对于每个生成的类T，有一些T_type_info，T_writer，T_reader类，它们仅在概念上与T相关。

我想做的是这样的事情：

template <class T> class Wrapper
{
public:
   template <class W> W topic_cast(BrokenBaseClassWriter* p);
   // other operations with the same problem ...
};

template <> class Wrapper<MyTopic>
{
public:
    template <> MyTopicWriter* topic_cast(BrokenBaseClassWriter* p) { ... }
};

这样我可以做以下事情：

void Write(const Wrapper<T>& topic)
{
    BrokenBaseClassWriter p = not_important;
    topic.topic_cast(p)->do_stuff();
}

我的T类是从IDL生成的，是应用程序空间中存在的概念。它们不是来自任何东西。在上面的例子中，W并不是一个独立的参数，它是“Something Not T依赖于T”。我试图在应用程序中保留T的所有知识，并在后端保留T'的所有知识（不知道T）。

然而，编译器说我的topic_cast函数不是模板函数 - 我认为因为模板出现在返回类型中，并且它不能与任何其他实例区分开来。我知道（模板只有返回类型不同）是不合法的。只有在我的情况下它才真正独特，因为W不是一个独立的参数。但是与编译器争论很少有用。

我可以这样做，还是有另一种方法可以做到这一点“作为模板类型的功能”？

Answer 1

使用特征系统无法实现这一目标吗？

template <typename T> struct my_traits
{
};

template <> struct my_traits<MyClass>
{
  typedef MyWriter writer_type;
};

template <typename T> struct Wrapper
{
  typename my_traits<T>::writer_type topic_cast();
};

Answer 2

这不起作用：

topic.topic_cast(p)->do_stuff();

因为编译器无法推断出返回类型因此，您必须明确告诉编译器您想要的返回类型：

topic.topic_cast<MyType>(p)->do_stuff();

您提供的实施是针对特定类型的因此，当您使用该特定类型时，将生成代码：

topic.topic_cast<MyTopicWriter>(p)->do_stuff();   // Use the explicit specialization

Answer 3

这用gcc：

编译

class BrokenBaseClassWriter;
class MyTopic;
class MyTopicWriter;

template <class T> class Wrapper
{
public:
   template <class W> W *topic_cast(BrokenBaseClassWriter* p);
   // other operations with the same problem ...
};




template <> template<> 
MyTopicWriter *Wrapper<MyTopic>::topic_cast<MyTopicWriter>(BrokenBaseClassWriter* p)
{
  return 0;
}


int main(int argc, int argv)
{
  BrokenBaseClassWriter* p = NULL;
  Wrapper<MyTopic> caster;
  MyTopicWriter *casted = caster.topic_cast<MyTopicWriter>(p);
}

当然，它仍会在主代码中公开MyTopicWriter ......

模板返回类型/转换为模板的功能

3 个答案: