内联 lambda 参数的 C++ 概念

Question

我正在尝试将 lambda（通过引用捕获本地上下文）传递给函数并确保它是内联的。 我认为一个解决方案是使用函数模板和 C++20 概念，但我不知道如何编写采用特定类型的 lambda 概念。

目的是分解光栅文件上的复杂循环，并让调用者为每个像素执行代码。
必须内联 lambda 调用。

我运气不好：

• std::function：使用 lambda 的性能比在调用者代码中编写整个循环差 2 倍。
• 函数指针：带捕获（this 或局部变量）的 lambda 无法转换为函数指针
• 模板方法：我不能重载它，也不能像以前的解决方案那样容易地检查 lambda 类型。

性能不佳的工作代码：

// loop
template<typename T>
class Raster<T>
{
    template<typename FileDataType>
    void SaveToDisk(std::ostream& file, const std::function<FileDataType(T&)>& callback) const;
    template<typename FileDataType>
    void SaveToDisk(std::ostream& file, AnotherCallbackType...);
}

// call
class GeoRaster<double> : public Raster
{
    void Test()
    {
        // Creates a file containing "short" values, from a GeoRaster<double>
        SaveToDisk<short>(file, [&](double val)
        {
           // this lambda call must be inlined
           if (val == this->nodata)
           {
               return 255;
           }
           else
           {
              return short(val) / 16;
           }
        }
     }
});

你能帮我写一个这样的概念吗：

template<typename T, typename FileDataType>
concept SimpleWriteCallback = requires(T a) {
    { a } -> std::convertible_to<std::function<FileDataType(T&)>>;
};

template<typename FileDataType, SimpleWriteCallback<FileDataType> Callback>
void SaveToDisk(std::ostream& file, Callback& callback) const;

Answer 1

首先，我们必须从我们如何考虑约束开始：

template<typename T, typename FileDataType>
concept SimpleWriteCallback = /* ... */;

我们没有限制FileDataType 上的回调，FileDataType 是回调返回。相反，我们将它限制在我们传递给它的类型上：

template <typename F, typename T>
concept SimpleWriteCallback = std::invocable<F&, T&>;

然后你会像这样使用这个概念：

template <SimpleWriteCallback<T> F>
void SaveToDisk(std::ostream& file, F&& callback) const {
    using FileDataType = std::invoke_result_t<F&, T&>;
    // ...
}

现在，单独地，如果您想覆盖实际的返回类型（正如您所做的那样，因为 lambda 返回一个 int 但您想要一个 short），您可以提供一个重载，让您提供显式输入并让其他重载转发给它：

template <typename FileDataType, SimpleWriteCallback<T> F>
    requires std::convertible_to<std::invoke_result_t<F&, T&>, FileDataType>
void SaveToDisk(std::ostream& file, F&& callback) const {
    // ...
}

template <SimpleWriteCallback<T> F>
void SaveToDisk(std::ostream& file, F&& callback) const {
    // by default, FileDataType is the actual invocation result
    SaveToDisk<std::invoke_result_t<F&, T&>>(file, callback);
}

Answer 2

我认为您正在寻找的是std::invocable，这是一个允许您强制使用给定参数集调用类型的概念：

#include <concepts>
#include <cstdio>

void do_stuff(std::invocable<int, int> auto &&fn) {
        fn(3, 4);
}

int main() {
        do_stuff([](const int a, const int b) { std::printf("%d %d\n", a, b); });
        // do_stuff([] { std::puts("hi!"); }); // won't compile

        return 0;
}

如果您还需要限制Func 的返回类型，您可以使用requires() 块添加复合要求：

template <typename Func>
        requires requires(Func &&fn, std::vector<int> v) {
                std::invocable<Func, const std::vector<int>&, bool>;
                { fn(v, false) } -> std::convertible_to<int>;
        }
int do_stuff(std::vector<int> v, Func &&fn) {
        v.push_back(31);

        return fn(v, true);
}

int main() {
    do_stuff({1, 2 ,3}, [](const auto &, bool) { return 3; }); // ok: right parameters, and return type is convertible to int
    do_stuff({1, 2 ,3}, [](const auto &, bool) { return 3.f; }); // ok: float is also implicitly convertible to int
    //do_stuff({1, 2 ,3}, [](const auto &v) { return 3; }); // won't compile, cannot be invoked with (const vector<int>&, bool)
    //do_stuff({1, 2 ,3}, [](const auto &v, bool) { return ""; }); // won't compile, const char (&)[] is not convertible to int
}