Deduction guides for functions as template parameters

Question

We can use std::unique_ptr to hold a pointer allocated with malloc which will be freed appropriately. However, the resulting std::unique_ptr's size will be 2 pointers, one for the pointer to the object and one for the pointer to the deleter function instead of the usual 1 pointer to object and an implicit delete. As one answer points out this can be avoided by writing a custom Unique_ptr that knows the proper deleter function. This function can be made known using a template parameter to support any deleter function like so:

template <class T, void (*Deleter)(T *)>
struct Unique_ptr {
    explicit Unique_ptr(T *t, void (*)(T *))
        : t{t} {}
    ~Unique_ptr() {
        Deleter(t);
    }
    //TODO: add code to make it behave like std::unique_ptr

    private:
    T *t{};
};

template <class T>
void free(T *t) {
    std::free(t);
}

char *some_C_function() {
    return (char *)malloc(42);
}

int main() {
    Unique_ptr<char, free> p(some_C_function(), free); //fine
    Unique_ptr q(some_C_function(), free);             //should be fine
                                                       //with the right
                                                       //deduction guide
}

This would be really nice if we could use deduction guides to not have to specify the template parameters. Unfortunately I can't seem to get the syntax right. These attempts fail to compile:

template <class T, auto Deleter>
Unique_ptr(T *, Deleter)->Unique_ptr<T, Deleter>;

template <class T, void (*Deleter)(T *)>
Unique_ptr(T *, void (*Deleter)(T *))->Unique_ptr<T, Deleter>;

Alternatively one could write Unique_ptr<free> q(some_C_function()); in order to manually specify the function template parameter, but that creates issues with deducing T.

What is the correct deduction guide to make Unique_ptr q(some_C_function(), free); or Unique_ptr<free> q(some_C_function()); compile?

Answer 1

Why write your own unique_ptr? Just use std::unique_ptr with a custom delete pointer. With C++17, that's very straightforward:

template <auto Deleter>
struct func_deleter {
    template <class T>
    void operator()(T* ptr) const { Deleter(ptr); }
};

template <class T, auto D>
using unique_ptr_deleter = std::unique_ptr<T, func_deleter<D>>;

Or, as Yakk suggests, more generally:

template <auto V>
using constant = std::integral_constant<std::decay_t<decltype(V)>, V>;

template <class T, auto D>
using unique_ptr_deleter = std::unique_ptr<T, constant<V>>;

which gets you to:

unique_ptr_deleter<X, free> ptr(some_c_api());

Sure, you have to actually write X, but you have no space overhead. In order to accomplish the same thing with deduction guides, you'd need to wrap the function deleter in order to lift it to a template parameter:

template <class T, auto D>
Unique_ptr(T*, func_deleter<D>) -> Unique_ptr<T, func_deleter<D> >;

Which would be used like:

Unique_ptr ptr(some_c_api(), func_deleter<free>());

I'm not sure that's necessarily better, and you run into all the same problems that led to the standard not having deduction guides for std::unique_ptr (i.e.: differentiating between pointers and arrays). YMMV.