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 )

一个模板化类型的alloca（）：怎么做？

1 个答案: