0

我的印象是我可以使用 reference_wrapper 生成一个函子，该函子将返回传递给 reference_wrapper ctor 的对象。但这行不通。我做错了吗？如果是这样，有没有更好的方法来实现这一点？我可以写一个 lambda，似乎我不应该这样做。

#include <iostream>
#include <functional>
using namespace std;

void funPtrPrinter( function< int( void ) > output )
{
    cout << output() << endl;
}

int main( void )
{
    int thirteen = 13;
    auto refWrap = ref( thirteen );
    funPtrPrinter( refWrap );
}
4

5 回答 5

2

A similar feature exists for member variables. Maybe you confused it with that.

struct foo { int bar; };

If you have a class with public member variables, you can use std::mem_fn and std::bind to create functors returning the value of the variable.

auto f = std::mem_fn(&foo::bar);
std::cout << f(foo{42}) << '\n';

auto g = std::bind(&foo::bar, foo{42});
std::cout << g() << '\n';
于 2014-03-07T17:51:14.547 回答
1

std::reference_wrapper不生成函子。Callable如果原始类型是-它只是一个函子，std::reference_wrapper::operator()仅当存储的引用是可调用类型时才可用。

目前尚不清楚为什么您需要仿函数，但如果是这种情况，那么 lambda 可能是最简单的解决方案。

于 2014-03-07T17:26:32.787 回答
0

reference_wrapper仅当它引用的对象是可调用的时才可调用。它operator()只是调用引用的可调用对象。如果引用的对象不可调用operator()，则不存在。从这个意义上说，它的行为就像一个“真实”的参考。

refWrap()将等价于thirteen()，所以格式不正确。

于 2014-03-07T17:28:06.540 回答
0

std::reference_wrapper::operator()仅在包装可调用对象时才参与重载决议。一个int不是一个，所以你要求的东西是行不通的。

你可以这样做：

int thirteen = 13;
auto refWrap = bind( [&thirteen] { return thirteen; } );
funPtrPrinter( refWrap );

现在您有了一个可调用的bind表达式，并且可以在funPtrPrinter().

如果我是你，我会跳过中间人并传入一个 lambda。

int thirteen = 13;
funPtrPrinter( [&thirteen] { return thirteen; } );
于 2014-03-07T17:28:50.527 回答
0

所以有一种方法可以使用std::integral_constant：

const int thirteen = 13;
auto refWrap = bind( &std::integral_constant< int, thirteen >::operator int, std::integral_constant< int, thirteen >() );

这确实解决了这个问题，但就所有意图和目的而言，它不如 lambda：

const int thirteen = 13;
auto refWrap = [=](){ return thirteen; };
于 2014-04-02T12:32:37.953 回答