Le Code de base pour un itérateur à accès aléatoire basé sur les pointeurs?

Je n'ai jamais mis en œuvre STL-comme les itérateurs et j'essaie de comprendre comment mettre en œuvre très simple basé sur les pointeurs. Une fois que j'aurai cette classe je vais être capable de le modifier pour faire plus de choses compliquées. Par conséquent, c'est une première étape, et j'en ai besoin pour être solide comme le roc pour comprendre comment écrire mon propre itérateurs (sans boost).

J'ai écrit le code suivant et je sais qu'il y a des erreurs. Pouvez-vous m'aider à concevoir correctement un Accès Aléatoire classe Iterator inspiré de :

template<Type> class Container<Type>::Iterator : public std::iterator<random_access_iterator_tag, Type>
{
//Lifecycle:
public:
Iterator() : _ptr(nullptr) {;}
Iterator(Type* rhs) : _ptr(rhs) {;}
Iterator(const Iterator &rhs) : _ptr(rhs._ptr) {;}
//Operators : misc
public:
inline Iterator& operator=(Type* rhs) {_ptr = rhs; return *this;}
inline Iterator& operator=(const Iterator &rhs) {_ptr = rhs._ptr; return *this;}
inline Iterator& operator+=(const int& rhs) {_ptr += rhs; return *this;}
inline Iterator& operator-=(const int& rhs) {_ptr -= rhs; return *this;}
inline Type& operator*() {return *_ptr;}
inline Type* operator->() {return _ptr;}
inline Type& operator[](const int& rhs) {return _ptr[rhs];}
//Operators : arithmetic
public:
inline Iterator& operator++() {++_ptr; return *this;}
inline Iterator& operator--() { --_ptr; return *this;}
inline Iterator& operator++(int) {Iterator tmp(*this); ++_ptr; return tmp;}
inline Iterator& operator--(int) {Iterator tmp(*this); --_ptr; return tmp;}
inline Iterator operator+(const Iterator& rhs) {return Iterator(_ptr+rhs.ptr);}
inline Iterator operator-(const Iterator& rhs) {return Iterator(_ptr-rhs.ptr);}
inline Iterator operator+(const int& rhs) {return Iterator(_ptr+rhs);}
inline Iterator operator-(const int& rhs) {return Iterator(_ptr-rhs);}
friend inline Iterator operator+(const int& lhs, const Iterator& rhs) {return Iterator(lhs+_ptr);}
friend inline Iterator operator-(const int& lhs, const Iterator& rhs) {return Iterator(lhs-_ptr);}
//Operators : comparison
public:
inline bool operator==(const Iterator& rhs) {return _ptr == rhs._ptr;}
inline bool operator!=(const Iterator& rhs) {return _ptr != rhs._ptr;}
inline bool operator>(const Iterator& rhs) {return _ptr > rhs._ptr;}
inline bool operator<(const Iterator& rhs) {return _ptr < rhs._ptr;}
inline bool operator>=(const Iterator& rhs) {return _ptr >= rhs._ptr;}
inline bool operator<=(const Iterator& rhs) {return _ptr <= rhs._ptr;}
//Data members
protected:
Type* _ptr;
};

Merci beaucoup.

Quelles erreurs? Les erreurs de compilation? L'éditeur de liens erreurs? Les erreurs d'exécution? Les erreurs de logiques? Quelque chose d'autre?
"Je sais qu'il y a des erreurs" -- est-ce une sorte de test? Je ne pense pas DONC est le bon site pour ça...
Un pointeur est un itérateur. Quel est le but de l'enveloppant avec une classe?
Le but est de comprendre comment appliquer correctement une classe iterator (notamment les signatures de fonction et de ce que la fonction n').
Eh bien, vous n'avez pas vraiment besoin public tous sur la place, mais comme vous n'avez pas de données membres en eux, il ne fait aucune différence. return Iterator(_ptr+rhs); en théorie crée un supplément temporaires inutiles, vous pouvez simplement return _ptr+rhs;.

OriginalL'auteur Vincent | 2012-08-23

  1. 0

    En général, votre démarche est la bonne. Le postfix incrémenter/décrémenter opérateur doit retourner en valeur, et non par référence. J'ai aussi des doutes au sujet de:

    Iterator(Type* rhs) : _ptr(rhs) {;}

    Cela dit tout le monde que cette classe iterator est mis en place autour de pointeurs. Je voudrais essayer de faire cette méthode uniquement appelable par le conteneur. Même pour l'affectation à un pointeur.
    L'ajout de deux itérateurs ne fait pas de sens pour moi (je laisse "itérateur+int"). Soustrayant deux itérateurs pointant vers le même conteneur peut faire un certain sens.

    Comme il le dit, c'est un exercice éducatif, c'est pourquoi il va le porc entier. J'ai été surpris par operator[] trop, mais il est là pour un accès aléatoire itérateurs! en.cppreference.com/w/cpp/concept/RandomAccessIterator
    merci. Il fixe.
    Je crois que vous avez besoin inline difference_type operator-(const Iterator&) au lieu de inline Iterator operator-(const Iterator&). Je ne crois pas que vous avez besoin de la même chose pour operator+. Certains algorithmes (comme std::sort) ne semblent pas fonctionner sans la difference_type operator-. Vous ne pouvez pas avoir les deux car seuls les types de retour différents.

    OriginalL'auteur Alexander Chertov

  2. 9

    Votre code comporte les questions suivantes:

    • Vous ne suivez pas la Règle de Trois/Cinq. La meilleure option dans votre situation est de ne pas déclarer tous les destructeurs, copier/déplacer les constructeurs ou les copier/déplacer des opérateurs d'affectation. Suivons donc appelé la Règle de Zéro.
    • Iterator(Type* rhs) pourrait être privé et le Container pourrait être marqué comme Iterator'ami, mais ce n'est pas strictement nécessaire.
    • operator=(Type* rhs) est une mauvaise idée. Ce n'est pas ce type de sécurité est d'environ.
    • Post(de)crementation doit retourner Iterator, pas Iterator &.
    • L'ajout de deux itérateurs n'a pas de sens.
    • Soustraction de deux itérateurs doit retourner une différence, non pas un nouvel itérateur.
    • Vous devez utiliser std::iterator<std::random_access_iterator_tag, Type>::difference_type au lieu de const int &.
    • Si une méthode ne permet pas de modifier un objet, il doit être marqué const.

    Ressource utile: RandomAccessIterator @ cppreference.com

    Ici est une version fixe de votre code:

    template<typename Type>
class Container<Type>::Iterator : public std::iterator<std::random_access_iterator_tag, Type>
{
public:
using difference_type = typename std::iterator<std::random_access_iterator_tag, Type>::difference_type;
Iterator() : _ptr(nullptr) {}
Iterator(Type* rhs) : _ptr(rhs) {}
Iterator(const Iterator &rhs) : _ptr(rhs._ptr) {}
/* inline Iterator& operator=(Type* rhs) {_ptr = rhs; return *this;} */
/* inline Iterator& operator=(const Iterator &rhs) {_ptr = rhs._ptr; return *this;} */
inline Iterator& operator+=(difference_type rhs) {_ptr += rhs; return *this;}
inline Iterator& operator-=(difference_type rhs) {_ptr -= rhs; return *this;}
inline Type& operator*() const {return *_ptr;}
inline Type* operator->() const {return _ptr;}
inline Type& operator[](difference_type rhs) const {return _ptr[rhs];}
inline Iterator& operator++() {++_ptr; return *this;}
inline Iterator& operator--() { --_ptr; return *this;}
inline Iterator operator++(int) const {Iterator tmp(*this); ++_ptr; return tmp;}
inline Iterator operator--(int) const {Iterator tmp(*this); --_ptr; return tmp;}
/* inline Iterator operator+(const Iterator& rhs) {return Iterator(_ptr+rhs.ptr);} */
inline difference_type operator-(const Iterator& rhs) const {return Iterator(_ptr-rhs.ptr);}
inline Iterator operator+(difference_type rhs) const {return Iterator(_ptr+rhs);}
inline Iterator operator-(difference_type rhs) const {return Iterator(_ptr-rhs);}
friend inline Iterator operator+(difference_type lhs, const Iterator& rhs) {return Iterator(lhs+rhs._ptr);}
friend inline Iterator operator-(difference_type lhs, const Iterator& rhs) {return Iterator(lhs-rhs._ptr);}
inline bool operator==(const Iterator& rhs) const {return _ptr == rhs._ptr;}
inline bool operator!=(const Iterator& rhs) const {return _ptr != rhs._ptr;}
inline bool operator>(const Iterator& rhs) const {return _ptr > rhs._ptr;}
inline bool operator<(const Iterator& rhs) const {return _ptr < rhs._ptr;}
inline bool operator>=(const Iterator& rhs) const {return _ptr >= rhs._ptr;}
inline bool operator<=(const Iterator& rhs) const {return _ptr <= rhs._ptr;}
private:
Type* _ptr;
};
    Iterator operator++(int) const - ne peut pas être const

    OriginalL'auteur cubuspl42

  3. 2

    Avoir un regard sur la façon de Stimuler le faire, les itérateurs dans boost/conteneur/vecteur.php - vector_const_iterator et vector_iterator sont raisonnablement facile à comprendre pointeur de fonction des itérateurs.

    OriginalL'auteur Silas Parker