Question

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

因此我正在寻找像C ++ 11 unique_ptr这样的东西，它管理所有权并允许提供自定义auto_ptr。

正如标题所示，我无法访问C ++ 11的功能。据我所知，delete并不是一个观众，因为它会调用free而不是bq query --allow_large_results --replace --destination_table=me.Tbl_MyTable '`cat query.txt`'。

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

Answer 1

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

但为了比较，这里是基于malloc / free的所有权转移指针的最小袖口C ++ 11及更高版本代码，如std::unique：

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的结果用作构造函数参数时，只有移动构造函数才能适合。虽然在一个完全不同的背景下使用volatile作为标签在C ++ 03中的想法曾经由Andrei Alexandrescu介绍过;可能是他之前的其他人，但据我记得他的用法是我第一次遇到这个想法。

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

#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().

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

带有free（）的C ++ 03智能指针

1 个答案: