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

Question

我正在为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);
};

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

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

Answer 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方式被称为const正确 。