Come fornire un contenitore di tipo STL con iteratore const pubblico e iteratore privato non const?

Question

Ho una classe che include un elenco std :: e desidero fornire public begin() e end() per const_iterator e private begin() e end() per un semplice iteratore.

Tuttavia, il compilatore sta visualizzando la versione privata e si lamenta che è privato anziché utilizzare la versione pubblica const.

Capisco che C++ non sovraccaricherà sul tipo restituito (in questo caso const_iterator e iterator) e quindi sta scegliendo la versione non-const poiché il mio oggetto non è const.

In mancanza di trasmettere il mio oggetto a const prima di chiamare begin() o non sovraccaricare il nome begin esiste un modo per ottenere ciò?

Penso che questo sia un modello noto che le persone hanno risolto prima e vorrebbe seguire l'esempio di come questo è in genere risolto.

class myObject { 
public: 
    void doSomethingConst() const; 
}; 

class myContainer { 
public: 
    typedef std::list<myObject>::const_iterator const_iterator; 
private: 
    typedef std::list<myObject>::iterator iterator; 

public: 
    const_iterator begin() const { return _data.begin(); } 
    const_iterator end() const { return _data.end(); } 
    void reorder(); 
private: 
    iterator begin() { return _data.begin(); } 
    iterator end() { return _data.end(); } 
private: 
    std::list<myObject> _data; 
}; 

void myFunction(myContainer &container) { 
    myContainer::const_iterator itr = container.begin(); 
    myContainer::const_iterator endItr = container.end(); 
    for (; itr != endItr; ++itr) { 
    const myObject &item = *itr; 
    item.doSomethingConst(); 
    } 
    container.reorder(); // Do something non-const on container itself. 
} 

L'errore del compilatore è qualcosa di simile:

../../src/example.h:447: error: `std::_List_iterator<myObject> myContainer::begin()' is private 
caller.cpp:2393: error: within this context 
../../src/example.h:450: error: `std::_List_iterator<myObject> myContainer::end()' is private 
caller.cpp:2394: error: within this context 

Grazie.

-William

Answer 1

Penso che la tua unica opzione sia quella di rinominare i metodi privati ​​(se ne hai bisogno in primo luogo).

Inoltre Credo che si dovrebbe rinominare i typedef:

class MyContainer 
{ 
public: 
    typedef std::list<Object>::const_iterator iterator; 
    typedef iterator const_iterator; 

    const_iterator begin() const; 
    const_iterator end() const; 

private: 
    typedef std::list<Object>::iterator _iterator; 
    _iterator _begin(); 
    _iterator _end(); 
    ... 
}; 

I contenitori dovrebbero typedef sia iterator e const_iterator. Una funzione generica che accetta un'istanza non const del tuo contenitore potrebbe aspettarsi di utilizzare il typedef iterator, anche se non modificherà gli elementi. (Per esempio BOOST_FOREACH.)

Va bene per quanto riguarda la correttezza const, perché se la funzione generica tenta effettivamente di modificare gli oggetti, il tipo di iteratore reale (essendo uno const_iterator) non lo consente.

Come test, il seguente dovrebbe compilare con il vostro contenitore:

int main() 
{ 
    myContainer m; 
    BOOST_FOREACH(const myObject& o, m) 
    {} 
} 

noti che m non è const, ma ci sta solo cercando di ottenere riferimenti const ai tipi contenute, quindi questo dovrebbe essere permesso.

Answer 2

cattiva idea deriva da std :: list (che non è progettato per essere derivato da).

Utilizzare una variabile membro di tipo std :: list.

class myContainer 
{ 
    std::list<myObject> m_data; 
    public: 

    typedef std::list<myObject>::const_iterator myContainer::const_iterator; 
    private: 
    typedef std::list<myObject>::iterator myContainer::iterator; 

    public: 

    myContainer::const_iterator begin() const 
    { 
     return m_data.begin(); 
    } 

    myContainer::const_iterator end() const 
    { 
     return m_data.end(); 
    } 

    private: 
    myContainer::iterator begin() 
    { 
     return m_data.begin(); 
    } 

    myContainer::iterator end() 
    { 
     return m_data.end(); 
    } 
}; 

Answer 3

È necessario modificare il nome della fine di inizio privato. Il compilatore non può differenziare da solo il tipo di ritorno

Questo funziona per me: Prendere nota dei nomi _begin _end

#include <list> 


class myObject {}; 

class myContainer : private std::list<myObject> { 
public: 
    typedef std::list<myObject>::const_iterator const_iterator; 
private: 
    typedef std::list<myObject>::iterator iterator; 

public: 
    myContainer::const_iterator begin() const { 
    return std::list<myObject>::begin(); 
    } 
    myContainer::const_iterator end() const { 
    return std::list<myObject>::end(); 
    } 
private: 
    myContainer::iterator _begin() { 
    return std::list<myObject>::begin(); 
    } 
    myContainer::iterator _end() { 
    return std::list<myObject>::end(); 
    } 
}; 

void myFunction(myContainer &container) { 
    myContainer::const_iterator aItr = container.begin(); 
    myContainer::const_iterator aEndItr = container.end(); 
    for (; aItr != aEndItr; ++aItr) { 
    const myObject &item = *aItr; 
    // Do something const on container's contents. 
    } 
} 

int main(){ 
    myContainer m; 
    myFunction(m); 
} 

Answer 4

Si potrebbe desiderare di cambiare la firma del metodo Myfunction a questo:

void myFunction(const myContainer &container) 

perché un metodo const può essere chiamato solo su un oggetto const. Quello che sta accadendo attualmente è che stai provando a chiamare un metodo non-const che nel tuo caso è privato.