c++ - 类型为 : how to do this? 的模板化数组的 alloca()

Question

我有一个智能指针类型，我想构造一个对象，该对象采用该类型的指针和一个计数(在运行时动态计算)，并从堆栈中分配足够的内存来容纳该智能对象的许多实例指针指向。我似乎找不到实现此目的的正确语法；可能吗？

给定这样的东西

template<typename T>
class PointerWrapper
{
public:
    PointerWrapper( T const * _pointer ): m_pointer(_pointer) {}
    typedef T Type;
    T const * m_pointer;
};

template<typename T>
class SomeObject: public NoCopyOrAssign
{
public:
    SomeObject( void * _allocaBuffer, PointerWrapper<T> _source, int _count );
};

我想做这样的事情:

void Test( PointerWrapper<int> _array, int _count )
{
    SomeObject<int> object = MakeSomeObject( _array, _count );
    // do some work with object
};

调用以下宏的代码无法编译，因为编译器无法从 _wrappedPtr 中推断出 SomeObject 的模板参数，因此会提示模板参数丢失:

#define MakeSomeObject(_wrappedPtr, _runtimeCount) \
    SomeObject(alloca(sizeof(_wrappedPtr::Type)*_runtimeCount), \
                    _wrappedPtr, _runtimeCount)

如果使用基于指针包装类型的函数模板，虽然编译器可以隐式推导类型，但调用它的代码不会编译，因为 SomeObject 故意定义但不实现复制构造函数或赋值运算符；即使它确实编译了它也不会做正确的事情，因为 alloca() 提供的内存会立即超出范围:

template<typename WrappedT>
SomeObject<typename WrappedT::Type> MakeSomeObject
    ( WrappedT _pointer, uint _runtimeCount )
{
    return SomeObject<typename WrappedT::Type>
        ( alloca(sizeof(typename WrappedT::Type)*_runtimeCount),
         _pointer, _runtimeCount );
}

我想避免将类型作为参数传递给宏，因为在实际代码中，这会导致在使用时出现非常冗长、难以阅读的语句，但我想这是一个后备方案，如果没有比这更好的了。

Answer 1

没关系，解决了；诀窍是结合这两种方法:

template<typename WrappedT>
SomeObject<typename WrappedT::Type> _MakeSomeObject
    ( void *_buffer, WrappedT _pointer, int _runtimeCount )
{
    return SomeObject<typename WrappedT::Type>
        ( _buffer, _pointer, _runtimeCount );
}

template<typename WrappedT>
int SizeT( WrappedT const _dummy ) { return sizeof(typename WrappedT::Type); }

#define MakeSomeObject(_wrappedPtr, _runtimeCount) \
        _MakeSomeObject( alloca(SizeT(_wrappedPtr)*_runtimeCount), \
             _wrappedPtr, _runtimeCount )