为旧式C链表界面提供C ++迭代器

Question

I have a Visual Studo 2008 C++ application where I am trying to add iterator support to a legacy C-API's linked-list structure. The C interface looks like this:

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

I would like to be able to use it like this:

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

    return 0;
}

So, I've created these 3 classes. But, my MyInfoIterator class has a problem with the operator->() . I can't return a temporary pointer to MyInfo , so I get the error: error C2440: 'return' : cannot convert from 'MyInfo' to 'const MyInfo *'

What is a good solution to this problem?

/// 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

Thanks, PaulH

Edit:

I cannot change the legacy API or it's associated structure.

Edit2:

I think I have a working solution that preserves my intent of hiding the underlying linked-list implementation and maintains the separation of responsibilities for each class by returning the address of a 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; 
};

Answer 1

Keep it simple :

class MyInfoIterator 
    : public std::iterator< std::input_iterator_tag, _LINKED_LIST_INFO >
{
   _LINKED_LIST_INFO* p;
public;
    MyInfoIterator(_LINKED_LIST_INFO* pointer) : p(pointer) {}

    [Same as you did]

    value_type& operator*() { return *p; }
}

Answer 2

I believe your value_type is wrong ... if you inherit STL iterator as an interface the value type needs to be of the type you contain. In your case you say that you contain elements of MyInfo but you are attempting to return a LINKED_LIST_INFO*

Either return a MyInfo or declare your iterator container to have a value_type of LINKED_LIST_INFO .

Probably want the first option as you may need the helper class for accessor methods to be able to properly manipulate the members of the struct.

Edit:

Naturally you should realize that simply having a std::vector<LINKED_LIST_INFO> or std::vector<MyInfo> gives you all the functionality you need with none of the implementation and maintenance issues.

Edit #2:

Actually you can't have a std::vector<MyInfo> because it's not default constructible so once you resolve your current error you will get another one based on typedef std::vector< MyInfo > MyBuffer; which will fail to resolve in template construction until you provide a default constructor for MyInfo

Edit #3:

Your value_type operator*() { return *elem_; } value_type operator*() { return *elem_; } is rather improperly formed. You should not return a copy of the internal object after this binary operation. You should return a reference. In your case you're treating this as a deref rather than a multiplication operation which is fine but a copy-by-value return is still wrong.

Answer 3

It looks like just returning the address of elem_ should do it.

const value_type* operator->() { return &elem_; };

Are you sure it wouldn't be less work to change your legacy list to a std::list or std::vector as appropriate though?

Answer 4

This is horrible (you should not do this) :

class MyInfo {
   char* name() const {
      return ((_LINKED_LIST_INFO*)this)->name;
   }
};

class MyInfoIterator 
: public std::iterator< std::input_iterator_tag, MyInfo>
{
   _LINKED_LIST_INFO* p;
public:
    MyInfoIterator(LINKED_LIST_INFO* pointer) : p(pointer) {}

    [Same as you did]

    reference operator*() const { return *(MyInfo*)p; }
};

The clean way is probably :

class MyInfo {
public:

  [...]

  private:
    const LINKED_LIST_INFO* elem_;
}

class MyInfoIterator 
: public std::iterator< std::input_iterator_tag, MyInfo>
{
   mutable MyInfo p;
public:
    MyInfoIterator(LINKED_LIST_INFO* pointer) : p(pointer) {}

    [...]

    reference& operator*() const { return p; }
    pointer_type operator->() const { return &p; }
};

This is how some Boost iterator are implemented (I mean the clean way, not the first one), see [1] for example.

[1] http://www.boost.org/doc/libs/1_46_1/libs/iterator/doc/counting_iterator.html