Implementing Custom Deleters with std::unique_ptr as Class Members in C++

Introduction

In modern C++ programming, std::unique_ptr serves as a core component of smart pointers, providing automated resource management. However, when dealing with third-party libraries or legacy code, resource creation and destruction are often handled through specific function pairs, such as create() and destroy() functions. In such cases, the default deleter is insufficient, requiring custom deleter configuration. This article thoroughly examines multiple approaches to implementing custom deleters with std::unique_ptr as class members.

Problem Scenario Analysis

Consider the following typical scenario: a class Foo needs to manage a Bar-type resource from a third-party library, which provides specialized creation and destruction functions:

Bar* create();
void destroy(Bar*);

In standalone functions, we can easily configure custom deleters using lambda expressions:

void standalone_function() {
    std::unique_ptr<Bar, void(*)(Bar*)> bar(create(), [](Bar* b){ destroy(b); });
    // Use bar
}

However, when std::unique_ptr is used as a class member, the configuration approach must be adjusted to ensure proper resource lifecycle management.

Primary Implementation Approaches

Concise Implementation Using Function Pointers

The most straightforward solution utilizes function pointers as the deleter type. Since the destroy function itself meets the deleter interface requirements, it can be used directly as a deleter:

class Foo {
private:
    std::unique_ptr<Bar, void(*)(Bar*)> ptr_;

public:
    Foo() : ptr_(create(), destroy) {
        // Constructor initialization
    }

    // Other member functions
};

This approach's advantage lies in its simplicity and clarity, requiring no additional deleter code. The second template parameter of std::unique_ptr specifies the deleter type as a function pointer, and the constructor directly passes the address of the destroy function.

Flexible Solution with Lambda Expressions

For scenarios requiring more complex deletion logic, std::function combined with lambda expressions provides greater flexibility:

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

class Foo {
private:
    deleted_unique_ptr<Bar> ptr_;

public:
    Foo() : ptr_(create(), [](Bar* b){ destroy(b); }) {
        // Constructor initialization
    }

    // Other member functions
};

This solution allows capturing context variables or implementing complex deletion logic but introduces some runtime overhead.

Type-Safe Approach with Custom Deleter Classes

Defining specialized deleter classes offers better type safety and compile-time optimization:

struct BarDeleter {
    void operator()(Bar* b) const {
        destroy(b);
    }
};

class Foo {
private:
    std::unique_ptr<Bar, BarDeleter> ptr_;

public:
    Foo() : ptr_(create()) {
        // Constructor initialization
    }

    // Other member functions
};

Since BarDeleter is a stateless deleter, modern C++ compilers apply empty base class optimization, preventing any increase in std::unique_ptr memory footprint.

Advanced Optimization Techniques

C++17 Non-Type Template Parameter Optimization

C++17 introduces non-type template parameters, further simplifying deleter definitions:

template <auto fn>
struct deleter_from_fn {
    template <typename T>
    constexpr void operator()(T* arg) const {
        fn(arg);
    }
};

template <typename T, auto fn>
using my_unique_ptr = std::unique_ptr<T, deleter_from_fn<fn>>;

// Usage example
class Foo {
private:
    my_unique_ptr<Bar, destroy> ptr_;

public:
    Foo() : ptr_(create()) {
        // Constructor initialization
    }
};

C++11/C++14 Compatible Solution

For pre-C++17 environments, type template parameters can achieve similar functionality:

template <typename D, D fn>
struct deleter_from_fn {
    template <typename T>
    constexpr void operator()(T* arg) const {
        fn(arg);
    }
};

template <typename T, typename D, D fn>
using my_unique_ptr = std::unique_ptr<T, deleter_from_fn<D, fn>>;

// Usage example
class Foo {
private:
    my_unique_ptr<Bar, decltype(&destroy), destroy> ptr_;

public:
    Foo() : ptr_(create()) {
        // Constructor initialization
    }
};

Performance and Memory Considerations

When selecting a deleter implementation, consider the following performance impacts:

1. Function Pointer Approach: sizeof(std::unique_ptr<T, void(*)(T*)>) is typically 2 * sizeof(T*) due to storing the function pointer
2. Custom Deleter Class Approach: Stateless deleters benefit from empty base class optimization, maintaining the same memory footprint as standard std::unique_ptr
3. std::function Approach: Offers maximum flexibility but may introduce runtime overhead and additional memory allocations

Practical Application Recommendations

In actual development, choose the appropriate solution based on specific requirements:

1. For simple function pointer deleters, the direct function pointer approach is most concise
2. When complex deletion logic or context capture is needed, consider the std::function approach
3. For performance-critical applications with fixed deletion logic, use custom deleter classes
4. In C++17 and later environments, leverage non-type template parameters to simplify code

Conclusion

Using std::unique_ptr as class members with custom deleters is an effective approach for managing third-party library resources in C++. By appropriately selecting the deleter implementation, developers can ensure safe resource release while balancing code simplicity and runtime efficiency. The multiple approaches discussed in this article address various scenario requirements, providing comprehensive technical guidance for developers.