1

我有一个智能指针类型，并且想构造一个对象，该对象接受该类型的指针和计数（在运行时动态计算）并从堆栈中分配足够的内存来保存智能指针指向的对象的许多实例. 我似乎找不到完全正确的语法来实现这一点；是否可以？

鉴于这样的事情

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 );
}

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

4

1 回答 1

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 )
于 2009-06-22T19:05:52.090 回答