C++03 带 free() 的智能指针

Question

我有一个 char 指针，我需要转移其所有权，如果可能的话，我宁愿不必自己处理它的生命周期。内存是使用 malloc 分配的(这里没有选择)。

因此，我正在寻找类似 C++11 的 unique_ptr 之类的东西，它管理所有权并允许提供自定义 Deleter。

正如标题所暗示的，虽然我无权访问 C++11 功能。据我所知，auto_ptr 并不是一个常见问题，因为它调用的是 delete 而不是 free。

在这种情况下是否有合适的智能指针，还是我必须自己管理内存的释放？

Answer 1

作为自己编写的替代方法，您可以引入对 Boost 的依赖，并只使用 boost::shared_ptr。

但为了比较，这里是基于 malloc/free 的所有权转移指针的最小即用 C++11 和更高版本代码，例如 std::独特:

template< class Type >
class My_ptr
{
private:
    Type* p_;

    My_ptr( My_ptr const& ) = delete;
    operator=( My_ptr const& ) -> My_ptr& = delete;

public:
    auto operator->() const
        -> Type*
    { return p; }

    auto operator*() const
        -> Type&
    { return *p; }

    ~My_ptr() { free( p_ ); }

    My_ptr( Type* p )
        : p_( p )
    {}

    My_ptr( My_ptr&& other )
        : p_( other.p_ )
    { other.p_ = nullptr; }
};

如您所见，C++11 中的代码并不多。

免责声明:以上代码未被编译器看到。

---

在 C++03 中，主要问题是如何使从函数返回智能指针成为可能，不允许一般的复制构造，这会造成严重破坏。

std::auto_ptr 使用的解决方案是涉及一个具有隐式转换的中介指针载体类。这很复杂。我记得当我写一个(曾经被维基百科引用过)指针教程时，在 Visual C++ 的 std::auto_ptr 实现中遇到了大量的特性。

下面的代码，希望是有效的 C++03(使用 g++ -std=c++03 测试)，而是基于程序员通过调用明确指示需要移动操作的位置as_movable 成员函数。它使用 volatile 作为一种标记，以确保当 as_movable 的结果用作构造函数参数时，只有移动构造函数才能适合。在 C++03 中使用 volatile 作为标签的想法，尽管是在完全不同的上下文中，曾经由 Andrei Alexandrescu 提出；可能是他之前的其他人，但据我记得他的用法是我第一次遇到这个想法。

放置分配和释放运算符operator new 和operator delete 是为异常安全 定义的。特别是，当相关类型的构造函数通过抛出指示失败时，此处定义的放置 operator delete 仅由 new 表达式隐式调用一个异常(exception)。然后在重新抛出异常之前使用此运算符释放内存。

#include <exception>    // std::terminate
#include <new>          // std::bad_alloc
#include <stddef.h>     // size_t
#include <stdlib.h>     // malloc, free, NULL

#define MY_NEW( type, args ) \
    ::new type args

#define MY_MALLOC( type, args ) \
    ::new( my::c_memory_management ) type args

namespace my {
    struct C_memory_management {};
    C_memory_management const c_memory_management = C_memory_management();
}  // namespace my

void*
    operator new( size_t const size, my::C_memory_management )
{
    void* result = malloc( size );
    if( not result ) { throw std::bad_alloc(); }
    return result;
}

// This operator is (only) called automatically by a new-expression where the
// constructor for the type, throws. After the call the exception is re-thrown.
void operator delete( void* const p, my::C_memory_management )
{
    free( p );
}

#ifdef SUPPORT_ARRAYS
    void*
        operator new[]( size_t const size, my::C_memory_management const cmm )
    {
        return operator new( size, cmm );
    }

    void operator delete[]( void* const p, my::C_memory_management const cmm )
    {
        operator delete( p, cmm );
    }
#endif

namespace my {
    template< class Referent >
    struct Destruction_via_delete_
    {
        static void destroy( Referent const* p )
        {
            try
            {
                delete p;
            }
            catch( ... )
            {
                std::terminate();
            }
        }
    };

    template< class Referent >
    struct Destruction_via_free_
    {
        static void destroy( Referent const* p )
        {
            try
            {
                p->~Referent();
            }
            catch( ... )
            {
                std::terminate();
            }
            ::free( const_cast<Referent*>( p ) );
        }
    };

    template< class Referent >
    class Auto_ptr_
    {
    public:
        typedef void Destruction_func( Referent const* );

    private:
        Auto_ptr_& operator=( Auto_ptr_ const& );   // No copy assignment.
        Auto_ptr_( Auto_ptr_ const& );              // No COPYING via copy constructor.
        // A non-const argument copy constructor, for moving, is defined below.

        Referent*           p_;
        Destruction_func*   destroy_func_;

        static void dummy_destroy_func( Referent const* ) {}

    public:
        Auto_ptr_ volatile&
            as_movable()
        { return const_cast<Auto_ptr_ volatile&>( *this ); }

        Referent*
            release()
        {
            Referent* result = p_;
            p_ = NULL;
            return p_;
        }

        Referent*
            operator->() const
        { return p_; }

        Referent&
            operator*() const
        { return *p_; }

        ~Auto_ptr_()
        { destroy_func_( p_ ); }

        Auto_ptr_()
            : p_( NULL )
            , destroy_func_( &dummy_destroy_func )
        {}

        explicit Auto_ptr_(
            Referent* const             p,
            Destruction_func* const     destroy_func    = &Destruction_via_delete_<Referent>::destroy
            )
            : p_( p )
            , destroy_func_( destroy_func )
        {}

        explicit Auto_ptr_(
            C_memory_management,        // tag
            Referent* const             p
            )
            : p_( p )
            , destroy_func_( &Destruction_via_free_<Referent>::destroy )
        {}

        // A C++03 emulation of move constructor; allows return of lvalue.
        Auto_ptr_( Auto_ptr_ volatile& other )
            : p_( other.p_ )
            , destroy_func_( other.destroy_func_ )
        {
            other.p_ = NULL;
            other.destroy_func_ = &dummy_destroy_func;
        }
    };

}  // namespace my

#include <stdio.h>

struct Blah
{
    char const* hello() const { return "Hello from Blah-land! :)"; }

    ~Blah() { printf( "<destroy>\n" ); }
    Blah() { printf( "<init>\n" ); }
};

my::Auto_ptr_< Blah >
    foo()
{
    using namespace my;
    Auto_ptr_< Blah  > p( c_memory_management, MY_MALLOC( Blah,() ) );
    return p.as_movable();
}

void bar( my::Auto_ptr_<Blah> const p )
{
    printf( "%s\n", p->hello() );
}

int main()
{
    my::Auto_ptr_<Blah> p = foo().as_movable();

    printf( "Calling bar()...\n" );
    bar( p.as_movable() );
    printf( "Returned from bar().\n" );
}

输出:

<init>Calling bar()...Hello from Blah-land! :)<destroy>Returned from bar().

免责声明:我没有为上面的代码编写任何单元测试，实际上唯一的测试就是上面显示的有效的测试。恕我直言，测试人们希望它适用的各种情况是在生产代码中使用它所必需的。