Question

根据http://en.cppreference.com/w/cpp/utility/functional/bind，std::bind

成员函数运算符（）

...

如果调用g（）时提供的某些参数不是   与存储在g中的任何占位符匹配，未使用的参数是   评估和丢弃。

引用示例，可以这样做：

void f(int n1, int n2, int n3, const int& n4, int n5) {
    std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
}

int main() {
    auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 is bound by _1, 2 is bound by _2, 1001 is unused
}

如果您将f1视为具有5个参数的函数，其中3个是固定的，那么您应该无法通过常识使用3个参数调用f1。但是，如上面的代码所示，您可以这样做，因为会忽略额外的参数。

根据Why do objects returned from bind ignore extra arguments?，这种行为似乎存在，因为它很方便实现??。

对我而言，这是一个相当令人困惑的库功能，因为它会混淆函数的优点（例如上面例子中的5 - 3 = 3）并且无法推理函数调用。我想知道是否有任何实际使用案例，这种行为实际上是有益的？

更重要的是，是否可以实施std::bind的变体来禁止此行为？这里有什么可能性和困难。

由于

Answer 1

注意：限制参数的数量会破坏说明here的活页夹功能。

我的解决方案基于~~计算传递的占位符~~，确定使用的最大占位符。感谢Xeo指出了这个错误。

#include <functional>
#include <type_traits>
#include <utility>

template<class T, class U>
constexpr auto c_max(T&& t, U&& u)
-> typename std::remove_reference<decltype( t > u ? t : u )>::type
{  return t > u ? t : u;  }

template<class...>
struct max_placeholder : std::integral_constant<int, 0> {};

template<class T, class... Rest>
struct max_placeholder<T, Rest...>
: std::integral_constant<int, c_max(std::is_placeholder<T>::value,
                                    max_placeholder<Rest...>::value)>
{};

这给正确计算活页夹用户数量的负担。对于某些绑定的Callables，例如函数指针，可以推断出参数的数量（这也允许自动提供所需数量的占位符）。一旦你修改了参数的数量，就可以很容易地编写一个存储绑定器的包装器，并提供一个operator()模板来检查参数的数量：

template<class T, int N>
struct strict_binder
{
    T binder;

    template<class... Args>
    auto operator()(Args&&... args)
    -> decltype( binder(std::forward<Args>(args)...) )
    {
        static_assert(sizeof...(args) == N, "wrong number of arguments");
        return binder(std::forward<Args>(args)...);
    }
};

也可能产生替换失败而不是错误。

由于strict_binder是binder，您可以通过部分专业化来表达这一概念：

namespace std
{
    template<class T, int N>
    struct is_bind_expression< strict_binder<T, N> >
        : public true_type
    {};
}

剩下的就是写一个产生strict_binder s的函数模板。这是一个与std::bind类似的版本：

template<class F, class... Args>
auto strict_bind(F&& f, Args&&... args)
-> strict_binder<
       typename std::decay<
            decltype( std::bind(std::forward<F>(f), std::forward<Args>(args)...) )
       >::type,
       max_placeholder<typename std::remove_reference<Args>::type...>::value
   >
{
    return { std::bind(std::forward<F>(f), std::forward<Args>(args)...) };
}

基本上，返回类型是

strict_binder<decltype(std::bind(f, args...)), count_placeholders<Args...>::value>

也就是说，strict_binder存储了std::bind的结果类型。

你也可以编写一个类似apply的函数，在没有占位符的情况下调用绑定函数：

template<int N, class F, class... Args>
auto strict_bind_or_call(std::integral_constant<int, N>, F&& f, Args&&... args)
-> strict_binder<
       typename std::decay<
            decltype( std::bind(std::forward<F>(f), std::forward<Args>(args)...) )
       >::type,
       N
   >
{
    return { std::bind( std::forward<F>(f), std::forward<Args>(args)... ) };
}

template<class F, class... Args>
auto strict_bind_or_call(std::integral_constant<int, 0>, F&& f, Args&&... args)
-> decltype( std::bind( std::forward<F>(f), std::forward<Args>(args)... ) () )
{
    return std::bind( std::forward<F>(f), std::forward<Args>(args)... ) ();
}

template<class F, class... Args>
auto strict_bind(F&& f, Args&&... args)
-> decltype( strict_bind_or_call( std::integral_constant<int, max_placeholder<typename std::remove_reference<Args>::type...>::value>{},
                                  std::forward<F>(f), std::forward<Args>(args)... ) )
{
    using max_placeholder_here =
        max_placeholder<typename std::remove_reference<Args>::type...>;

    return strict_bind_or_call( max_placeholder_here{},
                                std::forward<F>(f), std::forward<Args>(args)... );
}

这使用标签分派来返回绑定器或调用该函数的结果。我正确地放弃了格式化，你可能想在detail命名空间中引入别名模板。

注意decltype( std::bind(..) () )第二次重载中的strict_bind_or_call是重现INVOKE / bind语义的简单方法。我不能只写f(args...)因为f可能是成员函数。

用法示例：

#include <iostream>

void foo(int p0, int p1)
{ std::cout << "[" << p0 << ", " << p1 << "]\n"; }

int main()
{
    auto f0 = strict_bind(foo, std::placeholders::_1, 42);
    f0(1);

    strict_bind(foo, 1, 2);
}

c ++：如何编写一个std :: bind-like对象来检查超级参数？

1 个答案: