防止在不同类型的d::f中包裹lambda

Question

我有一个类，它的构造函数采用 std：：函数

我很惊讶这能起作用:

#include <functional>
#include <iostream>

template <typename T>
class Thing {
public:
  using Handler = std::function<void(T)>;

  Thing(Handler handler)
  : handler_(handler)
  {}

  Handler handler_;
};

int main() {

  Thing<double> foo([](int bar) {  // Conversion to void(int) from void(double)
    std::cout << bar;
  });

  foo.handler_(4.2);

  return 0;
}

...并在没有警告的情况下编译：

$ clang --std=c++11 -lc++ -Wall -Werror test.cc
$ ./a.out
4

看起来这样的转换可能会导致不必要的副作用。我无法想象这是一种期望的行为。




Answer 1

匿名用户

对于非捕获 lambda，您可以依赖它们衰减为指向函数的指针这一事实。
使用以下行：

using Handler = void(*)(T);

而不是< code>Handler的当前定义。< br >这样，除非您将参数类型更改为预期的类型，否则您将收到一个错误。

换句话说，这(不)像预期的那样工作:

#include <functional>
#include <iostream>

  template <typename T>
  class Thing {
  public:
    using Handler = void(*)(T);

    Thing(Handler handler)
    : handler_(handler)
    {}

    Handler handler_;
};

int main() {
    // switch the type of bar to double and it will compile
    Thing<double> foo([](int bar) {
        std::cout << bar;
    });

    foo.handler_(4.2);
    return 0;
}

请注意，如果您有lambdas的捕获列表，此解决方案将不再有效。< br >无论如何，它解决了问题中解释的问题。

Answer 2

您可以为参数使用仅允许转换为T的模板类：

template <typename T>
struct Strict {
    // This is a bit simplistic, but enough for fundamental types
    Strict(T t_) : t(t_) {}

    operator T() const { return t; }

    template<typename U>
    operator U() const = delete;

    T t;
};

template <typename T>
class Thing {
public:
    using Handler = std::function<void(Strict<T>)>;
    //...
};

演示

但是，请注意，使用这种方法，加宽的转换效果不佳：

// doesn't compile
Thing<int> foo{[](long long bar){});