通过模板参数编号重载模板类

发布于 2024-11-28 16:27:11 字数 299 浏览 0 评论 0原文

同一类是否可以有多个版本，仅在模板参数数量上有所不同？

例如：

template<typename T>
class Blah {
public:
    void operator()(T);
};

template<typename T, typename T2>
class Blah {
public:
    void operator()(T, T2);
};

我正在尝试对函子类型的事物进行建模，这些事物可以采用可变数量的参数（最多可达写出的不同模板的数量）。

原文

Is it possible to have multiple versions of the same class which differ only in the number of template arguments they take?

For instance:

template<typename T>
class Blah {
public:
    void operator()(T);
};

template<typename T, typename T2>
class Blah {
public:
    void operator()(T, T2);
};

I'm trying to model functor type things which can take a variable number of arguments (up to the number of different templates that were written out).

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

半边脸i 2024-12-05 16:27:11

最简单的答案是只有一个模板，其中包含您想要支持的最大数量，并使用 void 作为除第一种类型之外的所有类型的默认类型。然后您可以根据需要使用部分特化：

template<typename T1, typename T2=void>
struct foo {
    void operator()(T1, T2);
};

template <typename T1>
struct foo<T1, void> {
     void operator()(T1);
};

int main() {
   foo<int> test1;
   foo<int,int> test2;
   test1(0);
   test2(1,1);
}

The simplest answer would be to have just one template, with the maximum number you want to support and use void for a default type on all but the first type. Then you can use a partial specialization as needed:

template<typename T1, typename T2=void>
struct foo {
    void operator()(T1, T2);
};

template <typename T1>
struct foo<T1, void> {
     void operator()(T1);
};

int main() {
   foo<int> test1;
   foo<int,int> test2;
   test1(0);
   test2(1,1);
}

回复收藏 0 原文

那些过往 2024-12-05 16:27:11

模板只能有一个基本定义。如果您需要可变数量的参数，并且不想像 @awoodland 建议的那样使用“空类型”结构，并且如果您有 C++0x 编译器，那么您可以使用可变参数模板：

template <typename ...Dummy> struct foo; // base case, never instantiated!

template <typename T> struct foo<T> { /*...*/ };  // partial spec. for one parameter
template <typename T, typename U> struct foo<T, U> { /*...*/ };  // ditto for two

A template can have only one base definition. If you need a variable number of arguments and you don't want to use "null type" constructions as @awoodland suggests, and if you have a C++0x compiler, then you can use variadic templates:

template <typename ...Dummy> struct foo; // base case, never instantiated!

template <typename T> struct foo<T> { /*...*/ };  // partial spec. for one parameter
template <typename T, typename U> struct foo<T, U> { /*...*/ };  // ditto for two

回复收藏 0 原文

梦亿 2024-12-05 16:27:11

这是未经测试的代码，我没有方便的 boost 版本，但无论如何

#include "boost/tuple.h"

template <class T>
class Blah;

template <class T>
class Blah< boost::tuple<T> >
{
  void operator()(T arg);
};

template <class T, class U>
class Blah< boost::tuple<T, U> >
{
  void operator()(T arg1, U arg2);
};

等等。

This is untested code, I don't have a version of boost handy, but here goes anyway

#include "boost/tuple.h"

template <class T>
class Blah;

template <class T>
class Blah< boost::tuple<T> >
{
  void operator()(T arg);
};

template <class T, class U>
class Blah< boost::tuple<T, U> >
{
  void operator()(T arg1, U arg2);
};

etc. etc.

回复收藏 0 原文

~没有更多了~