C++ - 如何获取结构的最后一个成员类型以及从现有对象访问它的方法？

Question

有什么方法可以获取类的最后一个成员类型，并可能以某种方式从现有对象(指向类成员的指针)访问它。我需要这个来实现我自己的 new 和 delete 内置运算符。

有什么办法可以检查吗？

基本上我想做的是:

struct S
{
    int b;
    int arr[];
} ;

struct S1
{
    double d;
} ;

last_member_of<S1>::type //type of 'S1::d' - 'double'

last_member_of<S>::type //type of 'S::arr' - 'int []'

last_member_of<S>::value // 'S::*' pointing to 'S::arr'

last_member_of<S1>::value // 'S1::*' pointing to 'S1::d'

想法是，如果最后一个成员是灵活数组(我知道 ISO C++ 不正式支持它，但谁在乎大多数编译器何时真正支持它)- 我重新定义的运算符将能够分配/为其释放额外的存储空间，自动调用所有构造函数和析构函数。

Answer 1

以下是技术方面的操作，假设数组的 POD 项目类型:

struct S
{
    int b;
    int arr[1];

    auto operator new( size_t const size, int const n )
        -> void*
    {
        return ::operator new( size + (n-1)*sizeof( int ) );
    }

    void operator delete( void* p )
    {
        ::operator delete( p );
    }
};

auto main() -> int
{
    auto pS = new( 42 ) S;
    // USe it.
    delete pS;
}

免责声明:编译器未触及代码。

对于通用设施，只需概括一下即可。例如。您可以将灵活数组的项目类型作为模板参数传递。没有必要将几乎所有事情都自动化:显式是好的，隐式是坏的。

---

说了这么多，为了实用，只需在其中使用一个std::vector。

---

附录:OP 要求直接解决方案，我有时间编写一个。好吧，除了我没有解决非数组部分的构造函数参数问题，或者在 general 中用于数组项，或者 const 访问器。提示 OP 关于参数:std::forward 是你的 friend 。

同样，这一切都值得。使用 std::vector 是

• 特定的已知内存布局，例如以适应一些现有的 C 函数。
• 单个动态分配。

#include <iostream>
#include <functional>   // std::function
#include <memory>       // std::unique_ptr, std::default_delete
#include <new>          // std::operator new( size_t, void* )
#include <stddef.h>     // size_t
#include <stdexcept>    // std::exception, std::runtime_error
#include <stdlib.h>     // EXIT_FAILURE, EXIT_SUCCESS
#include <string>       // std::string

namespace cppx {
    using std::function;
    using std::string;
    using std::unique_ptr;
    using std::runtime_error;

    auto fail( string const& s ) -> bool { throw runtime_error( s ); }

    class Non_copyable
    {
    private:
        using This_class = Non_copyable;
        This_class& operator=( This_class const& ) = delete;
        Non_copyable( This_class const& ) = delete;

    public:
        Non_copyable() {}
        Non_copyable( This_class&& ) {}
    };

    template< class Common_data, class Item >
    class Flexible_array
        : public Non_copyable
    {
    template< class T > friend class std::default_delete;
    private:
        union Start_of_array
        {
            Item first_item;
            char dummy;

            ~Start_of_array() {}
            Start_of_array(): dummy() {}
        };

        int                     size_;
        Common_data             data_;
        Start_of_array          items_;

        // Private destructor prevents non-dynamic allocation.
        ~Flexible_array()
        {
            for( int i = size_ - 1; i >= 0; --i )
            {
                p_item( i )->~Item();
            }
        }

        Flexible_array( int const size ): size_( size ) {}

        // Private allocation function prevents client code dynamic allocation.
        // It also servers the purpose of allocating the right size for the array.
        static auto operator new( size_t const n_bytes, int const n )
            -> void*
        { return ::operator new( n_bytes + (n - 1)*sizeof( Item ) ); }

        // Matching operator delete for the case where constructor throws.
        static void operator delete( void* const p, int )
        { ::operator delete( p ); }

        // General operator delete.
        static void operator delete( void* const p )
        { ::operator delete( p ); }

    public:
        auto size() const           -> int              { return size_; }
        auto data()                 -> Common_data&     { return data_; }
        auto p_item( int const i )  -> Item*            { return &items_.first_item + i; }
        auto item( int const i )    -> Item&            { return *p_item( i ); }


        void destroy() { delete this; }

        static auto create( int const size, function< void( int id, void* p_storage ) > construct )
            -> Flexible_array*
        {
            unique_ptr< Flexible_array > p_flex{ new( size ) Flexible_array( size ) };
            for( int i = 0; i < size; ++i )
            {
                try
                {
                    construct( i, p_flex->p_item( i ) );
                }
                catch( ... )
                {
                    p_flex->size_ = i;
                    throw;
                }
            }
            return p_flex.release();
        }

        static auto create( int const size, Item const& default_value )
            -> Flexible_array*
        { return create( size, [&]( int, void* p ) { ::new( p ) Item( default_value ); } ); }

        static auto create( int const size )
            -> Flexible_array*
        { return create( size, [&]( int, void* p ) { ::new( p ) Item(); } ); }
    };
}  // namespace cppx

struct X
{
    int id;

    ~X() { std::clog << "X " << id << " destroyed\n"; }

    X( int const i )
        : id( i )
    {
        if( i == 5 ) { cppx::fail( "Intentional failure of X 5 construction" ); }
        std::clog << "X " << id << " created\n";
    }

    X( X const& other )
        : id( other.id )
    {
        std::clog << "X " << id << " copy-created\n";
    }
};

auto main() -> int
{
    using namespace std;
    try
    {
        using Flex = cppx::Flexible_array< int, X >;
        unique_ptr<Flex> const p{ Flex::create(
            7 ,
            X( 42 )     // or e.g. "[]( int i, void* p ) { ::new( p ) X( i ); }"
            ) };
        return EXIT_SUCCESS;
    }
    catch( exception const& x )
    {
        cerr << "!" << x.what() << "\n";
    }
    return EXIT_FAILURE;
}