指针转换错误C ++

Question

I write a simple list class that part of is look like that: When I try to build the project the compilers shows 3 errors that one of them is with pointer conversion problems and I cant get why:

Compiler error says:

1. 'MyList::Node *MyList::begin(void)': cannot convert 'this' pointer from 'const MyList' to 'MyList &'
2. 'MyList::Node *MyList::end(void)': cannot convert 'this' pointer from 'const MyList' to 'MyList &'
3. 'MyList::create': no overloaded function takes 1 arguments

The class(only little part..)

template<class T>
class MyList
{   
public:

    typedef T* iterator;
    typedef const T* const_iterator;
    typedef T value_type;
    typedef T& reference;
    typedef const T& const_reference;
    struct Node
    {
        T data;
        Node* prev;
        Node* next;
    };
    typedef Node* node_iterator;


    node_iterator begin() { return first; }
    node_iterator end() { return last; }

    ...

    MyList() { create(); }//default constructor
    MyList(size_type n, const T& val = T()){create(n, val);}
    MyList(const MyList& l) { create(l.begin(), l.end()); }//copy constructor
    MyList& operator=(const MyList&);//assignment operator
    ~MyList() { uncreate(); }

private:

    node_iterator first;
    node_iterator last;
    ...
    ...

};

MyList<T> & MyList<T>::operator=(const MyList& rhs)
{
    if (&rhs != this)
    {
        uncreate();
        create(rhs.begin(), rhs.end());
    }
    return *this;
}

template<class T>
void MyList<T>::create(node_iterator a, node_iterator b)
{
    ...
}

Answer 1

You are calling

create(rhs.begin(), rhs.end());

Where rhs is a const object. But you are calling begin and end that requires the object to not be const. Either change

 MyList<T> & MyList<T>::operator=(const MyList& rhs)

to

 MyList<T> & MyList<T>::operator=(MyList& rhs)

Or make begin and end work for const objects. ie node_iterator begin() const { return first; } node_iterator begin() const { return first; }

Fix this then work on any other compiler errors/warnings.