Using automatic deduction with unique_ptr and custom deleter

Question

I'm currently using a C library that defines a number of data types, all of which need to have their lifetimes managed by the user. There are a number of functions defined in this fashion:

int* create() {
    return new int();
}

void destroy(int* i) {
    delete i;
}

Most of these don't need to be accessed after creation. They simply need to exist. Because of this, I'm trying to manage them using unique_ptr's declared in the scope of which I need them to live.

This is how such a declaration looks like:

// Note that I'm avoiding writing the type's name manually.
auto a = std::unique_ptr<std::decay_t<decltype(*create())>, decltype(&destroy)>{create(), &destroy};

But this is overly verbose, so I encapsulated it in a utility function template:

template<typename T>
auto make_unique_ptr(T* p, void (*f)(T*)) {
    return std::unique_ptr<T, decltype(f)>(p, f);
}

Which is used this way:

auto b = make_unique_ptr(create(), &destroy);

This looks nice, but introduces a non-standard function that has no real purpose other than being syntactic sugar for some declarations. My colleagues may not even know it exists and end up creating other versions of it with different names.

c++17 Introduced class template argument deduction. I thought this is the perfect solution to my problem: A standard way to deduce all those types without resorting to user-defined wrappers. So I tried this:

auto c = std::unique_ptr{create(), &destroy};

As is the rule with C++ compilers and templates, this fails with a several lines long error message. Here are the relevant parts:

(...): error: class template argument deduction failed:
 auto c = std::unique_ptr{create(), &destroy};
                                            ^
(...): note: candidate: 'template<class _Tp, class _Dp> 
unique_ptr(std::unique_ptr<_Tp, _Dp>::pointer, typename std::remove_reference<_Dp>::type&&)-> std::unique_ptr<_Tp, _Dp>'
       unique_ptr(pointer __p,
       ^~~~~~~~~~
(...): note:   template argument deduction/substitution failed:
(...): note:   couldn't deduce template parameter '_Tp'
     auto c = std::unique_ptr{create(), &destroy};
                                                ^

Theoretically, I could add a deduction guide to handle this:

namespace std {

template<typename T>
unique_ptr(T* p, void (*f)(T*)) -> unique_ptr<T, decltype(f)>;

}

And it does work at least on my version of gcc, but the standard doesn't like it very much:

[namespace.std]

1 Unless otherwise specified, the behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a namespace within namespace std.

4 The behavior of a C++ program is undefined if it declares
    (...)
    4.4 - a deduction guide for any standard library class template.

There's also some problems related to differentiating between pointers and arrays, but let's ignore that.

Finally, the question(s): Is there any other way to 'help' std::unique_ptr (or maybe std::make_unique) to deduce the correct type when using custom deleters? Just in case this is an XY problem, is there any solutions I didn't think of for lifetime management of those types (perhaps std::shared_ptr)? If both of those answers are a negative, is there any improvements on c++20 I should be looking forward to, that solve this issue?

Feel free to test the above examples at Coliru.

Answer 1

I would recommend writing custom deleters rather than using function pointers. Using the function pointer would make all the unique_ptrs twice the size for no reason.

Instead, write a deleter templated on a function pointer:

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

Or, as Yakk - Adam Nevraumont mentioned in the comments:

template <auto deleter_f>
using Deleter = std::integral_constant<std::decay_t<decltype(deleter_f)>, deleter_f>;

Using it becomes pretty clean:

auto a = std::unique_ptr<int, Deleter<destroy>>{create()};

Although you might want to combine this with your make_unique_ptr function:

template <auto deleter_f, typename T>
auto create_unique_ptr(T* ptr)
{
    return std::unique_ptr<T, Deleter<deleter_f>>{ptr};
}

// Usage:
auto a = create_unique_ptr<destroy>(create());

Answer 2

A type as a value:

template<class T>
struct tag_t {};
template<class T>
constexpr tag_t<T> tag{};

A value as a type:

template<auto f>
using val_t = std::integral_constant<std::decay_t<decltype(f)>, f>;
template<auto f>
constexpr val_t<f> val{};

Note that val<some_function> is an empty type that can be invoked in a constexpr context with () and it will call some_function. It can also store ints or whatever, but we are going to use it to store function pointers statelessly.

Now let's have fun:

namespace factory {
  // This is an ADL helper that takes a tag of a type
  // and returns a function object that can be used
  // to allocate an object of type T.
  template<class T>
  constexpr auto creator( tag_t<T> ) {
    return [](auto&&...args){
      return new T{ decltype(args)(args)... };
    };
  }
  // this is an ADL helper that takes a tag of a type
  // and returns a function object that can be used
  // to destroy that type
  template<class T>
  constexpr auto destroyer( tag_t<T> ) {
    return std::default_delete<T>{};
  }

  // This is a replacement for `std::unique_ptr`
  // that automatically finds the destroying function
  // object using ADL-lookup of `destroyer(tag<T>)`.
  template<class T>
  using unique_ptr = std::unique_ptr< T, decltype(destroyer(tag<T>)) >; // ADL magic here

  // This is a replacement for std::make_unique
  // that uses `creator` and `destroyer` to find
  // function objects to allocate and clean up
  // instances of T.
  template<class T, class...Args>
  unique_ptr<T> make_unique(Args&&...args) {
    // ADL magic here:
    return unique_ptr<T>( creator( tag<T> )(std::forward<Args>(args)...) );
  }
}

ok, that is a framework.

Now let's imagine you have some library. It has a type in it. It needs super secret special sauce to create and destroy instances of it here:

namespace some_ns {
  struct some_type {
    int x;
  };
  some_type* create( int a, int b ) {
    return new some_type{ a+b }; // ooo secret
  }
  void destroy( some_type* foo ) {
    delete foo; // ooo special
  }
}

and we want to connect it up. You reopen the namespace:

namespace some_ns {
  constexpr auto creator( tag_t<some_type> ) {
    return val<create>;
  }
  constexpr auto destoyer( tag_t<some_type> ) {
    return val<destroy>;
  }
}

and we are done.

factory::unique_ptr<some_ns::some_type> is the right type to store a unique ptr to some_type. To create it you just factory::make_unique<some_ns::some_type>( 7, 2 ) and you get a unique ptr of the correct type with a destroyer lined up, with zero memory overhead, and the call to the destroyer function involving no indirection.

Basically sweep std::unique_ptr and std::make_unique for factory::unique_ptr and factory::make_unique, then line up the creator/destroyer ADL helpers to make all unique ptrs to a given type just do the right thing.

Test code:

auto ptr = factory::make_unique<some_ns::some_type>( 2, 3 );
std::cout << ptr->x << "=5\n";
std::cout << sizeof(ptr) << "=" << sizeof(std::unique_ptr<some_ns::some_type>) << "\n";

live example.

This has zero runtime overhead over writing custom unique ptr types. If you don't overload creator or destroyer for a tag_t<X> in X's namespace (or in namespace factory), factory::make_unique returns a bog standard std::unique_ptr<X>. If you do, it injects compile-time information how to destroy it.

By default factory::make_unique<X> uses {} initialization so it works with aggregates.

The tag_t system is to enable ADL-based customization of factory::make_unique and factory::unique_ptr. It is useful elsewhere too. End users don't have to know about it, they just need to know you use factory::unique_ptr and factory::make_unique always.

Searching for std::make_unique and std::unique_ptr should find you cases where someone is violating this rule. Eventually (you hope) they'll notice all unique pointers are factory::unique_ptr instead of std.

The magic to add a type to the system is short enough and easy enough to copy that people can do it without having to understand ADL. I'd include a paragraph marked "you don't need to know this, but this is how this works" in comments somewhere.

This is possibly overdone; I was just thinking how I'd handle distributed traits and destruction/creation in c++17 with some of the new features. I haven't tried this in production, so there may be unrevealed problems.

Answer 3

You are overcomplicating things. Simply specialize std::default_delete for your custom types, and you can use a vanilla std::unique_ptr.

A shame that std::shared_ptr doesn't use the same customization-point, there you will have to supply the deleter explicitly.

Answer 4

One thing you could do is use a using statement to introduce an alias for std::unique_ptr<T, void (*)(T*)> like

template<typename T>
using uptr = std::unique_ptr<T, void (*)(T*)>;

Then you could use it like

auto u = uptr<int>{create(), &destroy};