iterator on map of pointers to objects as a key c++

Question

i'm implementing a backtracking algorithm to solve sudokus, but i have some issues using maps. could any one tell me why i get these two errors when compiling my code? the first error is about the line declaring the iterator on the map. the second one is when doing Adj[&node] = mList;

the errors:

Error C2664 'std::_Tree_const_iterator>>> std::_Tree>::find(Node *const &) const' : can't convert argument 1 from 'const Node *' to 'Node *const &'

Error C2679 '[' binary : no operator found accepting a right operand of type 'const Node *' (ou there's no acceptable conversion)

(my Visual studio is in french, so i translated the error messages. hope it's fine like this)

my code where i got the error:

template<class T>
void AdjList<T>::addElement(const Node<T>& node, const vector<Node<T>>& vecOfNeighbours) {
    typename map< Node<T>*, LinkedList<T>>::iterator mit = Adj.find(&node);
    if (mit!=Adj.end()) {
        LinkedList<T> mList;
        for (typename vector<Node<T>>::const_iterator it = vecOfNeighbours.begin(); it != vecOfNeighbours.end(); it++) {
            mList.Add((*it).getValue()[0]);
        }
        Adj[&node] = mList;
    }
}

my classes définitions :

template<class T>
class AdjList
{
private:
    map<Node<T>*, LinkedList<T>> Adj;
public:
    AdjList();
    AdjList(const AdjList<T>& adjlist);
    AdjList(const Node<T>& node, const vector<Node<T>>& vecOfNeighbours);
    void addElement(const Node<T>& node, const vector<Node<T>>& vecOfNeighbours);
    void Print() const;
};

template<class T>
class LinkedList
{
    Node<T>* head;
    int  getEndList();
    Node<T>* returnFrontEnd(void) const;

public:
    LinkedList();
    LinkedList(T data);
    LinkedList(const LinkedList<T>& list);
    LinkedList<T>& operator=(const LinkedList<T>& list);
    void Add(T data);
    void AddAt(int index, T data);
    void Print();
    ~LinkedList();
};

template<class T>
class Node
{
protected:
    vector<T> _value;
    Node<T>*  child;

public:
    Node(T value);
    void addValue(T value);
    Node<T>* clone() const;
    Node(const Node<T>& node);
    vector<T> getValue() const;
    Node<T>* returnChild() const;
    void AddChild(const Node<T>& node); 
    Node& operator=(const Node<T>& node);
    ~Node();
};

Answer 1

You need to cast away const . Why? Take a look:

void AdjList<T>::addElement(const Node<T>& node, const vector<Node<T>>&) 

Okay, so node is a const reference,

typename map< Node<T>*, LinkedList<T>>::iterator mit = Adj.find(&node);

But this iterator will have a non-const pointer. So if this were allowed, you'd be able to get a non-const pointer from a const reference. That clearly requires casting away const (which you don't do).