Template type to (statically) wrap a function?

Question

Does the C++ standards define a utility for wrapping a function in a type (as distinct from wrapping it in a value)?

After Googling a bunch of names that seem related, I'm not finding anything, but then again, I know of a few things where I'd never guess the name.

---

Edit:

• I already know how to get a type that can dynamically take on the value of a function (either std::function or a good old function pointers like int(*f)(int)) but that specifically excludes from the type the one thing I most want to include: the actual function to be called.
• I already know how to get the type of a function from its name (decltype(fn)) which is not what I want, for the same reasons as listed above.

---

I find myself needing to make a type where its operator() exactly matches a function foo (in my case, a C function from a 3rd part library). Ideally, the type should inline away to nothing any time it's used. As a one off, this is easy:

struct foo_t {
  ret_t operator()(SomeType t, int i) {
    return foo(t, i);
  }
};

However, there is at least one cases where this is a thing that needs to be done to a bunch of different functions: deleters for std::unique_ptr<T,D> while interfacing with opaque handles (e.g. from C libraries):

std::unique_ptr<FILE*, fclose_t> f(fopen(n, "r"));
std::unique_ptr<obj*, free_t> o((obj*)malloc(sizeof(obj)));
...

Rather than define fclose_t, free_t, etc. myself, what I'd like to do is something like this:

std::unique_ptr<FILE*, type_fn<fclose>> f(fopen(n, "r"));
std::unique_ptr<obj*, type_fn<free>> o((obj*)malloc(sizeof(obj)));
...

And that isn't even that hard... if you are happy to define type_fn yourself:

template<auto *f> struct fn_type {
  template<class... A>
  auto operator() (A&&... a) {
    return f(std::forward<A>(a)...);
  }
};

Which brings me back to the opening question: does C++ define something like that?

Answer 1

that isn't even that hard... if you are happy to define type_fn yourself...

Actually, you are not supposed to take the address of a function from the standard library(with some exceptions), since the library might make changes to a function that are compatible with a normal use of a function, but not with taking its address (for instance, adding a parameter with a default value, or adding an overload to an overload set).

In fact, taking the address of a function from the standard library is explicitly forbidden since C++20. More can be found here: Can I take the address of a function defined in standard library?

Which mean you can't write something like type_fn<fclose>.

---

A solution for you is to use a lambda, since the type of each lambdas are guaranteed to be unique:

auto deleter = [](auto *p){ std::fclose(p); };

Now, you can use decltype(deleter) anywhere you would need to specify a type for it:

auto f = std::uniqe_ptr<std::FILE, decltype(deleter)>(std::fopen("file", "r"));

If you only need this deleter once, you can also define the lambda just in the template parameter:

std::uniqe_ptr<std::FILE, decltype(
    [](auto *p){ std::fclose(p); }
)>(std::fopen("file", "r"));