为遗留的c链表接口提供c++迭代器

我有一个Visual studio 2008 c++应用程序，我试图将迭代器支持添加到遗留的C- api的链表结构中。C语言的接口是这样的:

typedef struct _LINKED_LIST_INFO {
    struct _LINKED_LIST_INFO* Next;
    const char* name;
    // more elements. some are fixed-size; others are pointers to other structures.
} LINKED_LIST_INFO;
DWORD GetLinkedList( LINKED_LIST_INFO* pInfo, PULONG pOutBufLen );

我希望能够这样使用它:

int _tmain( int /*argc*/, _TCHAR* /*argv*/[] )
{
    MyLinkedList elements;
    for( MyLinkedList::const_iterator it = elements.begin();
         it != elements.end();
         ++it )
    {
        printf( "Name: %srn", it->Name().c_str() );
    }
    return 0;
}

我创建了这3个类。但是，我的MyInfoIterator班有operator->()的问题。我不能返回MyInfo的临时指针，所以我得到错误:error C2440: 'return' : cannot convert from 'MyInfo' to 'const MyInfo *'

/// wrap the legacy C structure and provide C++ accessors
class MyInfo
{
public:
    MyInfo( const LINKED_LIST_INFO& info ) : elem_( info ) { };
    std::string Name() const { return elem_.name; };
private:
    /// one element of the linked list
    const LINKED_LIST_INFO& elem_;
}; // class MyInfo
namespace detail {
/// buffer to hold the legacy C linked-list
typedef std::vector< BYTE > MyBuffer;
/// iterator support for the legacy C linked-list
class MyInfoIterator 
    : public std::iterator< std::input_iterator_tag, MyInfo > 
{
public:
    explicit MyInfoIterator( MyBuffer& list ) : data_( list )
    {
        elem_ = reinterpret_cast< LINKED_LIST_INFO* >( &data_.front() );
    };
    MyInfoIterator() : elem_( NULL ) { };
    MyInfoIterator& operator++() 
    {
        elem_ = elem_->Next;
        return *this;
    };
    value_type operator*() { return *elem_; };
    //  error C2440: 'return' : cannot convert from 'MyInfo' to 'const MyInfo *'
    const value_type* operator->() { return elem_; };
    friend bool operator==( const MyInfoIterator& i, 
                            const MyInfoIterator& j ) 
    { 
        return i.elem_ == j.elem_;
    };
private:
    /// linked-list of elements
    MyBuffer data_;
    /// current position within the element list
    LINKED_LIST_INFO* elem_;
}; // class MyInfoIterator
bool operator!=( const MyInfoIterator& i, const MyInfoIterator& j ) 
{ 
    return !operator==( i, j );
}
}; // namespace detail
/// provide iterator access for the legacy C linked-list API
class MyLinkedList
{
public:
    typedef detail::MyInfoIterator const_iterator;
    const_iterator begin() const 
    { 
        ULONG size = sizeof( LINKED_LIST_INFO );
        detail::MyBuffer buffer( size );
        DWORD ec = ::GetLinkedList( 
            reinterpret_cast< LINKED_LIST_INFO* >( &buffer.front() ), &size );
        if( ERROR_BUFFER_OVERFLOW == ec )
        {
            buffer.resize( size );
            ec = ::GetLinkedList( 
                reinterpret_cast< LINKED_LIST_INFO* >( &buffer.front() ), &size );
        }
        if( ERROR_SUCCESS != ec )
            Win32Exception::Throw( ec );
        return const_iterator( buffer ); 
    };
    const_iterator end() const { return const_iterator(); };
}; // class MyInfo

谢谢,PaulH

我不能改变旧的API或它的相关结构。

Edit2:

我认为我有一个工作的解决方案，保留我隐藏底层链表实现的意图，并通过返回static MyInfo的地址来维护每个类的职责分离。

class MyInfo
{
   // ...
protected:
    MyInfo() : info_( NULL ) { };
    void Set( const LINKED_LIST_INFO* info ) { info_ = info; };
private:
    friend MyInfoIterator;
    const LINKED_LIST_INFO* info_;
};
const value_type& MyInfoIterator::operator*() const 
{ 
    static MyInfo info;
    info.Set( elem_ );
    return info;
};
const value_type* MyInfoIterator::operator->() const
{ 
    static MyInfo info;
    info.Set( elem_ );
    return &info; 
};