如何摆脱手动类模板参数规范

Question

是否有Finalizer比这更通用的方法来编写一个类？

#include <functional>
#include <iostream>

template <typename T>
class Finalizer
{
public:
    Finalizer(const std::function<T>& f) : _f(f) {}

    ~Finalizer()
    {
        _f();
    }

private:
    std::function<T> _f;
};

int main()
{
    Finalizer<void()> finalizer([]() { std::cout << "str" << std::endl; });
}

我想摆脱手动类模板参数规范,以便能够编写如下代码:

Finalizer finalizer([]() { std::cout << "str" << std::endl; });

可能吗？

Answer 1

在C++中,类型推导仅适用于函数模板,不适用于类模板.您需要一个make_finalizer函数来执行模板参数推导.

此外,您根本不必使用std::function,无需为运行时成本付费,除非您确实希望对其进行类型擦除.

template <typename F>
class Finalizer
{
public:
    Finalizer(const F & c) : f_(c) {}
    Finalizer(F && c) : f_(std::move(c)) {}
    Finalizer(const Finalizer &) = delete;
    Finalizer(Finalizer && other) : 
          valid_(other.valid),
          f_(std::move(other.f_))
    {
         other.valid_ = false;
    }

    Finalizer& operator=(const Finalizer &) = delete;
    Finalizer& operator=(Finalizer && other)
    {
         Finalizer tmp(std::move(other));
         swap(tmp);
         return *this;
    }

    ~Finalizer()
    {
        if ( valid_ )
           f_();
    }

    void swap(Finalizer & other) noexcept
    {
         using std::swap;
         swap(other.valid_, valid_);
         swap(other.f_, f_);
    }

private:
    bool valid_ = true;
    F f_;
};

template<class F>
Finalizer< std::remove_reference_t<F> > at_scope_exit(F && x)
{
    return Finalizer< std::remove_reference_t<F> >(std::forward<F>(x));
}

并与auto一起使用:

 auto x = at_scope_exit([]() { std::cout << "Hello world" << std::endl; });