iOS - PassBook自动更新(iOS - PassBook Automatic Updates)

 停止使用std::bind 。 这是一个随机的功能和怪癖混乱。 
 
 今天的怪癖是， std::bind将接受无限数量的参数并丢弃任何额外的参数。 明天你可能会遇到这样一个事实：将std::bind结果传递给std::bind会产生奇怪的效果。 
 
 std::bind被移植到同一时间增加了语言的lambdas。 Lambdas几乎解决了每个问题bind问题，就像清晰的语法一样，并且没有让怪癖bind问题，特别是在auto lambda表达式可用后的C ++ 14之后。 （大多数C ++ 11编译器也支持auto lambda）。 
 
 您可以编写函数，使其中一个或另一个在他们都适用时是首选的超载。 但是这样做会给你的界面增加一堆噪音，在这种情况下，你想要这个偏好的唯一原因是因为std::bind做了一些愚蠢的事情。 
 
 围绕设计不佳的std库进行工程是不值得的。 只需停止使用std库的设计不佳的地方，或者在明确使用的地方使用。 
 
 
 如果没有，请这样做： 
 
template <class T, class F,
  std::enable_if_t<
    std::is_convertible<
      std::result_of_t<std::decay_t<F> const&(Value<T> const&)>,
      bool
    >{}, int
  > = 0
>
void Add(Value<T> &value, F&& f)
{
  // do pass f Value<T>
}
template <class T, class F,
  std::enable_if_t<
    !std::is_convertible<
      std::result_of_t<std::decay_t<F> const&(Value<T> const&)>,
      bool
    >{}
    && std::is_convertible<
      std::result_of_t<std::decay_t<F> const&()>,
      bool
    >{}, int
  > = 0
>
void Add(Value<T> &value, F&& f)
{
  // do not pass f Value<T>
}
 
 我们在这里抛出一些令人讨厌的SFINAE检测，在你想使用的两个重载中选择哪一个，并明确地选择一个。 
 
 这不值得。 

Stop using std::bind. It is a mess of random features and quirks.
 
Todays quirk is that std::bind will accept an unlimited number of arguments and discard any extra ones. Tomorrow you might run into the fact that passing std::bind result to std::bind does strange magic.
 
std::bind was ported over to boost at the same time lambdas where added to the language. Lambdas solve almost every problem bind does in just as clear syntax and fails to have the myraid of quirks bind does, especially post C++14 when auto lambdas are available. (Most C++11 compilers also supported auto lambda).
 
You can write functions so that one or the other is the preferred overload when they both apply. But doing so adds a pile of noise to your interface, and in this case about the only reason why you'd want that preference is because std::bind is doing something stupid.
 
Engineering around a poorly designed bit of std library is not worth it. Simply stop using that poorly designed bit of std library, or at point of use cast explicitly.
 
 
Failing that, do this:
 
template <class T, class F,
  std::enable_if_t<
    std::is_convertible<
      std::result_of_t<std::decay_t<F> const&(Value<T> const&)>,
      bool
    >{}, int
  > = 0
>
void Add(Value<T> &value, F&& f)
{
  // do pass f Value<T>
}
template <class T, class F,
  std::enable_if_t<
    !std::is_convertible<
      std::result_of_t<std::decay_t<F> const&(Value<T> const&)>,
      bool
    >{}
    && std::is_convertible<
      std::result_of_t<std::decay_t<F> const&()>,
      bool
    >{}, int
  > = 0
>
void Add(Value<T> &value, F&& f)
{
  // do not pass f Value<T>
}
 
where we throw some nasty SFINAE detection on which of the two overloads you want to use, and explicitly prefer one.
 
This is not worth it.