带有运算符的函数模板

发布于 2024-07-26 23:21:44 字数 376 浏览 1 评论 0原文

在 C++ 中，类上可以有模板化运算符吗？就像这样：

class MyClass {
public:
    template<class T>
    T operator()() { /* return some T */ };
}

这实际上似乎编译得很好，但令人困惑的是如何使用它：

MyClass c;
int i = c<int>(); // This doesn't work
int i = (int)c(); // Neither does this*

它完全编译的事实向我表明它是可行的，我只是不知道如何使用它！有什么建议，或者这种使用方法行不通？

原文

In C++, can you have a templated operator on a class? Like so:

class MyClass {
public:
    template<class T>
    T operator()() { /* return some T */ };
}

This actually seems to compile just fine, but the confusion comes in how one would use it:

MyClass c;
int i = c<int>(); // This doesn't work
int i = (int)c(); // Neither does this*

The fact that it compiles at all suggests to me that it's doable, I'm just at a loss for how to use it! Any suggestions, or is this method of use a non-starter?

分享到QQ

分享到微博

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

发布评论

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

汹涌人海 2024-08-02 23:21:44

您需要指定T。

int i = c.operator()<int>();

不幸的是，在这种情况下您不能直接使用函数调用语法。

编辑：哦，您在类定义的开头缺少 public: 。

You need to specify T.

int i = c.operator()<int>();

Unfortunately, you can't use the function call syntax directly in this case.

Edit: Oh, and you're missing public: at the beginning of the class definition.

回复收藏 0 原文

奢望 2024-08-02 23:21:44

你基本上是对的。定义模板化运算符是合法的，但不能使用显式模板参数直接调用它们。

如果你有这个运算符：

template <typename T>
T operator()();

就像你的例子一样，它只能这样调用：

int i = c.operator()<int>();

当然，如果模板参数可以从参数中推导出来，你仍然可以用正常的方式调用它：

template <typename T>
T operator()(T value);

c(42); // would call operator()<int>

另一种方法是使参数引用，并将输出存储在那里，而不是返回它：

template <typename T>
void operator()(T& value);

因此，

int r = c.operator()<int>();

您可以这样做

int r;
c(r);

：或者您应该只定义一个简单的 get() 函数，而不是使用运算符。

You're basically right. It is legal to define templated operators, but they can't be called directly with explicit template arguments.

If you have this operator:

template <typename T>
T operator()();

as in your example, it can only be called like this:

int i = c.operator()<int>();

Of course, if the template argument could be deduced from the arguments, you could still call it the normal way:

template <typename T>
T operator()(T value);

c(42); // would call operator()<int>

An alternative could be to make the argument a reference, and store the output there, instead of returning it:

template <typename T>
void operator()(T& value);

So instead of this:

int r = c.operator()<int>();

you could do

int r;
c(r);

Or perhaps you should just define a simple get<T>() function instead of using the operator.

回复收藏 0 原文

一笔一画续写前缘 2024-08-02 23:21:44

您是否没有想到

class Foo {
    public:
    template<typename T>
    operator T() const { return T(42); }
};

Foo foo;

int i = (int) foo; // less evil: static_cast<int>(foo);

现场示例。这证明您不需要指定模板参数，尽管接受的答案中有这样的声明。

Aren't you thinking of

class Foo {
    public:
    template<typename T>
    operator T() const { return T(42); }
};

Foo foo;

int i = (int) foo; // less evil: static_cast<int>(foo);

live example. This proves you do not need to specify the template argument, despite the claim in the accepted answer.

回复收藏 0 原文

~没有更多了~