problemas con iteradores dentor de mi clase.

[juan_c65]

hola que tal, tengo porblemas al usar begin y end implementados para el tipo de dato lista_doble.

El problema es que cuando quiero usar begin y end para implementar un constructor de copia me sale el siguiente error.:

error: passing 'const lista_doble<int>' as 'this' argument of 'lista_doble<T>::iterator lista_doble<T>::begin() [with T = int]' discards qualifiers [-fpermissive]
for (auto x = lista.begin(); x != lista.end(); ++x){

no entiendo bien por qué. Basicamente lo que haces el constructor de copia es recorrer la lista pasada como parametro y agreagar al final de la nueva lista los datos. Les paso todo el codigo para que lo vean saludos.. y gracias:

#include <iostream>
#include <utility>

using namespace std;

template <typename T>

class lista_doble{
private:
struct nodo{
T dato;
nodo *sig;
nodo *ant;
};
nodo aux;
public:
//CONSTRUCTOR
lista_doble()
{
aux.ant = &aux;
aux.sig = &aux;
}

class iterator{
public:
friend class lista_doble;
nodo * actual;

using value_type = T;
using pointer = T *;
using reference = T &;
using difference_type = std::size_t;
using iterator_category = std::bidirectional_iterator_tag;


iterator(){
actual = nullptr;
}
iterator (nodo *p){
actual = p;
}

T & operator *(){
return actual->dato;
}

iterator & operator ++(){
actual = actual->sig;
return *this;//retorna el iterador a actual.
}

iterator operator ++(int){
iterator tmp = *this;
operator ++();
return tmp;
}

iterator &operator --(){
actual = actual->ant;
return *this;
}
iterator & operator --(int){
iterator tmp = *this;
operator --();
return tmp;
}

friend
bool operator == (const iterator &x, const iterator &y){
return x.actual == y.actual;
}

friend
bool operator != (const iterator &x, const iterator &y){
return !(x == y);
}

};

iterator begin(){
return iterator (aux.sig); //primer elemento. Iterador a puntero a nodo.
}
iterator end(){
return iterator (&aux); //iterador a nodo.
}

void insertar (iterator pos, T valor){//se pone pos.actual por que al ser un
nodo * nuevo = new nodo; //iterador una clase y ser la clase una
nodo *current = pos.actual;
nuevo->dato = valor; //estructura es como que accedemos a un
nuevo->ant = current->ant; //campo de la misma.
nuevo->sig = current;
nuevo->ant->sig = nuevo;
nuevo->sig->ant = nuevo;
//return iterator (nuevo);
}

iterator borrar (iterator pos){
nodo *p = pos.actual;
++pos;
p->ant->sig = p->sig;
p->sig->ant = p->ant;
delete p;
return iterator (pos);
}

void clear() {
auto p = begin();
while (p != end()) {
p = borrar(p);
}
}
//DESTRUCTOR
~lista_doble(){
clear();
}


void push_back(const T & value) {
insertar(end(), value);
}

//CONSTRUCTOR DE COPIA
//RECORDAR QUE EL SWAP DEL OPERADOR DE ASIGANCION HACE USO DEL CONSTRUCTOR DE COPIA.

lista_doble (const lista_doble & lista){
for (auto x = lista.begin(); x != lista.end(); ++x){
push_back(*x);
}
}

};

int main()
{
lista_doble <int> l;

l.push_back(67);
l.push_back(68);
l.push_back(69);

for (auto x = begin(l); x != end(l); ++x){
cout << *x << " ";
}
cout << endl;

lista_doble <int> l2;
l2.push_back(67);
l2.push_back(68);
l2.push_back(69);

lista_doble <int> l3 = l2;

return 0;
}
^