我正在用C++测试一个 Package 器对象，这是我的基本代码：

template <class res_type, class finisher_type, finisher_type finisher>
struct wrapper
{
    wrapper(res_type r, finisher_type) noexcept
    {
        item = r;
    }
    wrapper(res_type r) noexcept
    {
        item = r;
    }
    
    ~wrapper() noexcept
    {
        finisher(item);
    }

private:
    res_type item;
};

template <class func, func lambda = func()>
explicit wrapper(int, func)->wrapper<int, func, lambda>;

void test()
{
    int x = 0, y = 0;

    wrapper file{ x, [](int h) {if (h != -1 && h) close_resource(h); } };

    // void some_closer_function(int) {...}
    wrapper proc{ y, some_closer_function };
}

我面临两个问题。首先，在lambda捕获子句中放入任何内容都会使编译器抱怨'wrapper<int,func,lambda> wrapper(int,func)': could not deduce template argument for 'lambda'。这是因为带有捕获的lambda不能使用+转换为函数指针吗？
第二，使用some_closer_function的行编译，但由于演绎指南中的func lambda = func()，lambda是nullptr。我认为这是因为演绎指南中的func是函数指针，而不是函数类型本身。有没有办法强制它成为函数本身而不是函数指针，而不显式输入decltype(some_closer_function)？
编辑3/25/2023
我创建了一个派生类来保存一个lambda，但这次是一个捕获类，因为我之前的代码可以保存一个无捕获的lambda。新的派生类通过保存一个指向lambda的指针，然后通过该指针调用它来实现这一点。

template <class res_type, class finisher_type, finisher_type finisher = finisher_type()>
struct wrapper
{
    wrapper(res_type r, finisher_type) noexcept
    {
        item = r;
    }
    wrapper(res_type r) noexcept
    {
        item = r;
    }

    ~wrapper() noexcept
    {
        if constexpr (!std::is_same_v<finisher_type, std::nullptr_t>)
            finisher(item);
    }

protected:
    res_type item;
};

template <class res_type, class lambda_type>
struct custom_wrapper : wrapper<res_type, std::nullptr_t>
{
    custom_wrapper(res_type item, lambda_type const& lambda) : base(item)
    {
        this->lambda = &lambda;
    }

    ~custom_wrapper()
    {
        lambda->operator()(base::item);
    }

private:
    using base = wrapper<res_type, std::nullptr_t>;
    const lambda_type* lambda;
};

void test()
{
    int x, y;

    custom_wrapper wrapper{ 234, [&](int) {} };

    return;
}

虽然这确实使一切工作，但这是未定义的行为吗？我问这个问题是因为我相信捕获lambda是包含捕获的class。在这种情况下，lambda对象是临时对象吗？就像在custom_wrapper wrapper{ 234, [&](int) {} };行中一样，并在custom_wrapper完成创建时被销毁？当custom_wrapper被销毁时，它最终会调用一个被销毁的lambda吗