类型模板化数组的 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 )