c++11绑定和应用？

Question

std::bind 有时被描述为“部分应用程序”。为什么当一个函数的所有参数都被绑定时，函数本身没有被应用？

例如，以下代码不打印任何内容。

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

void f(int a,string b) {cout << a << b << endl;};
int main() {
  bind(bind(f,1,_1),"Hi!");
  return 0; 
}

有没有办法编写一个绑定变体，可以在所有参数都固定的情况下应用该函数？

--更新--

我现在从回复中了解到std::bind 并不完全是部分应用程序。所以，在问题的第二部分，我怎么能写像 std::bind 这样的东西，但做部分应用。 我知道bind(bind(f,1,_1),"Hi!")() 将调用最终的0 元函数并返回结果值（在示例中打印1Hi）。是否可以做模板编程在bind的终端情况下调用函数调用operator()？

也就是说，能不能写一个函数bind1：

template< class R, class F, class... Args >
bind1( F f, Args... args )

，这样当std::is_placeholder<T>::value == 0 为args 的每个成员时， bind1() 除了std::bind() 所做的之外，还可以调用operator() 吗？

Answer 1

没有参数的函数只是 Haskell 中的一个值。你不调用它，你只是使用它。由于没有副作用，因此没有可观察到的差异。

在 OCaml 中根本没有无参数函数，要获得类似的东西，您需要添加一个虚拟单元参数。

在 C++ 中并非如此。与 Haskell 和 OCaml 不同，C++ 在 f 和 f() 之间保持着明显的区别。 bind 为您提供前者，因为您始终可以通过添加 () 将其转换为后者。您可以为 bind 编写自己的包装器，这很容易做到。反过来会有点困难。

以下是此类包装器的可能实现：

#include <functional>
#include <utility>
#include <iostream>

template <typename T>
struct is_noargs_callable {
  private:
    typedef char(&yes)[1];
    typedef char(&no)[2];

    template<typename U> 
      static yes test(decltype((std::declval<U>())())*);

    template<typename> 
      static no test(...);

  public:
    static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};

template <typename T>
struct is_noargs_callable<T()> {
  static const bool value = true;
};

template <typename T>
struct is_noargs_callable<T(...)> {
  static const bool value = true;
};

template <typename T>
auto call_me_if_you_can(T t) -> typename std::enable_if<is_noargs_callable<T>::value, decltype(t())>::type
{
  return t();
}

template <typename T>
auto call_me_if_you_can(T t) -> typename std::enable_if<!is_noargs_callable<T>::value, T>::type
{
  return t; 
}

template <typename... Args>
auto apply(Args&&... args) -> decltype(call_me_if_you_can(std::bind(args...))) {
  return call_me_if_you_can(std::bind(args...));
}

// testing

void foo(int a, int b, int c) { std::cout << "foo(" << a << "," << b << "," << c << ")";  }

int main ()
{
  using namespace std::placeholders;
  std::cout << "zero : " ; apply(foo, _1, _2, _3); std::cout << " : " ; apply(foo, _1, _2, _3)(1,2,3); std::cout << std::endl;
  std::cout << "one  : " ; apply(foo, 1, _1, _2); std::cout << " : " ; apply(foo, 1, _1, _2)(2,3); std::cout << std::endl;
  std::cout << "two  : " ; apply(foo, 1, 2, _1); std::cout << " : " ; apply(foo, 1, 2, _1)(3); std::cout << std::endl;
  std::cout << "three: " ; apply(foo, 1, 2, 3);  std::cout << " : "; /* nothing to test here */ std::cout << std::endl;
}

但是，仅在这一点上消除 f 和 f() 之间的差异并不能恕我直言，这有助于 C++ 编程的整体一致性。如果你不喜欢这种区别，那就到处杀掉它（或者干脆用你的 Haskell 来做个好事）。

Answer 2

没有任何来源，只是我的看法。

没有这样做的原因是因为没有理由这样做。如果您知道该函数的所有输入，只需调用它即可。

如果您使用导致这种情况的模板进行操作，则无论如何您都需要一致地编写所有代码。这里的特殊情况只需要其他地方的特殊情况。