c++ - 如何存储通用引用

Question

我需要在类中存储通用引用(我确信引用的值将比类更有效)。有规范的方法吗？

这是我想出的一个最小示例。它似乎有效，但我不确定我是否做对了。

template <typename F, typename X>
struct binder
{
    template <typename G, typename Y>
    binder(G&& g, Y&& y) : f(std::forward<G>(g)), x(std::forward<Y>(y)) {}

    void operator()() { f(std::forward<X>(x)); }

    F&& f;
    X&& x;
};

template <typename F, typename X>
binder<F&&, X&&> bind(F&& f, X&& x)
{
    return binder<F&&, X&&>(std::forward<F>(f), std::forward<X>(x));
}

void test()
{
    int i = 1;
    const int j = 2;
    auto f = [](int){};

    bind(f, i)();   // X&& is int&
    bind(f, j)();   // X&& is const int&
    bind(f, 3)();   // X&& is int&&
}

我的推理是否正确，或者这会导致细微的错误吗？另外，有没有更好的(即更简洁的)方法来编写构造函数？ binder(F&& f, X&& x) 将不起作用，因为它们是右值引用，因此不允许 binder(f, i)。

Answer 1

你不能“存储通用引用”，因为没有这样的东西，只有右值引用和左值引用。 “通用引用”是 Scott Meyers 用来描述语法特征的方便术语，但它不是类型系统的一部分。

查看代码的具体细节:

template <typename F, typename X>
binder<F&&, X&&> bind(F&& f, X&& x)

在这里你要实例化binder以引用类型作为模板参数，因此在类定义中无需将成员声明为右值引用，因为它们已经是引用类型(由bind推导出的左值或右值) ).这意味着您总是有更多 &&超出需要的标记，它们是多余的并且由于引用崩溃而消失。

如果你确定binder将始终由您的 bind 实例化函数(因此总是用引用类型实例化)那么你可以这样定义它:

template <typename F, typename X>
struct binder
{
    binder(F g, X y) : f(std::forward<F>(g)), x(std::forward<X>(y)) {}

    void operator()() { f(std::forward<X>(x)); }

    F f;
    X x;
};

在此版本中，类型 F和 X是引用类型，所以使用 F&& 是多余的和 X&&因为它们要么已经是左值引用(所以 && 什么都不做)，要么是右值引用(所以 && 在这种情况下也什么都不做!)

或者，您可以保留 binder正如你所拥有的那样，改变bind到:

template <typename F, typename X>
binder<F, X> bind(F&& f, X&& x)
{
    return binder<F, X>(std::forward<F>(f), std::forward<X>(x));
}

现在实例化binder使用左值引用类型或对象(即非引用)类型，然后在 binder 中您使用额外的 && 声明成员所以它们要么是左值引用类型，要么是右值引用类型。

此外，如果你考虑一下，你不需要存储右值引用成员。通过左值引用存储对象非常好，重要的是你转发它们在 operator() 中正确地作为左值或右值。功能。所以类(class)成员可能只是F&和 X& (或者在您总是使用引用参数实例化类型的情况下， F 和 X )

所以我将代码简化为:

template <typename F, typename X>
struct binder
{
    binder(F& g, X& y) : f(g), x(y) { }

    void operator()() { f(std::forward<X>(x)); }

    F& f;
    X& x;
};

template <typename F, typename X>
binder<F, X> bind(F&& f, X&& x)
{
    return binder<F, X>(f, x);
}

此版本在模板参数中保留了所需的类型 F和 X并在 std::forward<X>(x) 中使用正确的类型表达式，这是唯一需要它的地方。

最后，我发现从推导类型的角度思考更准确、更有帮助，而不仅仅是(折叠的)引用类型:

bind(f, i)();   // X is int&, X&& is int&
bind(f, j)();   // X is const int&, X&& is const int&
bind(f, 3)();   // X is int, X&& is int&&