迭代器实现 - （链表队列）答案

【问题标题】：Iterator Implementation - (Linked List Queue)迭代器实现 - （链表队列）
【发布时间】：2016-02-01 07:53:47
【问题描述】：

我正在为 Queue 数据类型实现迭代器，但由于某种原因，迭代器在类实现中被初始化为 const。我无法弄清楚为什么构造函数导致迭代器将自身作为 const 返回。

任何关于可能导致我的问题的复杂 C++ 语言的反馈都会非常有帮助。

我从 Eclipse 收到的错误似乎来自我的 begin() 方法：

../src/linked_queue.hpp:315:35: error: invalid conversion from 
    'const ics::LinkedQueue<int>*' to 'ics::LinkedQueue<int>*' [-fpermissive]

界面：

#ifndef LINKED_QUEUE_HPP_
#define LINKED_QUEUE_HPP_

#include <string>
#include <iostream>
#include <sstream>
#include <initializer_list>
#include "ics_exceptions.hpp"


namespace ics {


template<class T> class LinkedQueue {
  public:
    //Destructor/Constructors
    ~LinkedQueue();

    LinkedQueue          ();
    LinkedQueue          (const LinkedQueue<T>& to_copy);
    explicit LinkedQueue (const std::initializer_list<T>& il);


    template <class Iterable>
    explicit LinkedQueue (const Iterable& i);


    //Queries
    bool empty      () const;
    int  size       () const;
    T&   peek       () const;
    std::string str () const; //supplies useful debugging information; contrast to operator <<


    //Commands
    int  enqueue (const T& element);
    T    dequeue ();
    void clear   ();

    template <class Iterable>
    int enqueue_all (const Iterable& i);


    //Operators
    LinkedQueue<T>& operator = (const LinkedQueue<T>& rhs);
    bool operator == (const LinkedQueue<T>& rhs) const;
    bool operator != (const LinkedQueue<T>& rhs) const;

    template<class T2>
    friend std::ostream& operator << (std::ostream& outs, const LinkedQueue<T2>& q);



  private:
    class LN;

  public:
    class Iterator {
      public:

        ~Iterator();
        T           erase();
        std::string str  () const;
        LinkedQueue<T>::Iterator& operator ++ ();
        LinkedQueue<T>::Iterator  operator ++ (int);
        bool operator == (const LinkedQueue<T>::Iterator& rhs) const;
        bool operator != (const LinkedQueue<T>::Iterator& rhs) const;
        T& operator *  () const;
        T* operator -> () const;
        friend std::ostream& operator << (std::ostream& outs, const LinkedQueue<T>::Iterator& i) {
          outs << i.str(); 
          return outs;
        }
        friend Iterator LinkedQueue<T>::begin () const;
        friend Iterator LinkedQueue<T>::end   () const;

      private:

        LN*             prev = nullptr;  
        LN*             current;         
        LinkedQueue<T>* ref_queue;
        int             expected_mod_count;
        bool            can_erase = true;

        Iterator(LinkedQueue<T>* iterate_over, LN* initial);
    };


    Iterator begin () const;
    Iterator end   () const;


  private:
    class LN {
      public:
        LN ()                      {}
        LN (const LN& ln)          : value(ln.value), next(ln.next){}
        LN (T v,  LN* n = nullptr) : value(v), next(n){}

        T   value;
        LN* next = nullptr;
    };


    LN* front     =  nullptr;
    LN* rear      =  nullptr;
    int used      =  0;            //Cache for number of values in linked list
    int mod_count =  0;            //For sensing any concurrent modifications

    //Helper methods
    void delete_list(LN*& front);
};

实现（我只包含了我的迭代器代码的一部分）：

template<class T>
auto LinkedQueue<T>::begin () const -> LinkedQueue<T>::Iterator {
    return Iterator(this, this->front);
}

template<class T>
auto LinkedQueue<T>::end () const -> LinkedQueue<T>::Iterator {
    // return Iterator(this, this->rear);
}

template<class T>
LinkedQueue<T>::Iterator::Iterator(LinkedQueue<T>* iterate_over, LN* initial) {
    ref_queue = iterate_over;
    expected_mod_count = iterate_over->mod_count;
    current = initial;
}

【问题讨论】：

Iterator begin () const; 被标记为const，因此函数中使用的this 也是const。因此，编译器又会给出无法从 const 转换为非 const 的错误。
可以理解。但是我把它当作一个类，我应该以这种方式实现函数，那么有什么方法可以正确实现Iterator / begin函数，以便我可以将自身的引用传递给Iterator？跨度>
您可以将const 添加到构造函数签名Iterator(LinkedQueue<T> const* iterate_over, LN* initial); 和成员const 以及LinkedQueue<T> const* ref_queue;

标签： c++ eclipse data-structures queue

【解决方案1】：

错误是因为Iterator begin () const;被标记为const，因此函数中使用的this也是const。因此，编译器又会给出无法从 const 转换为非 const 的错误。

鉴于在这种情况下已修复函数签名，为了解决错误，添加 const 将有助于解决问题。

您可以在构造函数签名中添加const

Iterator(LinkedQueue<T> const* iterate_over, LN* initial);

并且让成员const 为好

LinkedQueue<T> const* ref_queue;

在需要的地方添加const 以确保成员和函数按需要保持const 称为being const correct。

【讨论】：