C ++错误：成员请求...属于非类型

Question

我已经尝试过查看其他类似的问题，但它们似乎都包含有关我使用的c11功能的答案。

运行以下代码时出现错误：

  

错误：请求会员＆＃39;当前＆＃39;在   ＆＃39; （（MTM :: MtmSet ）此） - ＆GT; MTM :: MtmSet :: it.mtm :: MtmSet：迭代::操作符 - ＆GT;（）＆＃39; ，这是非类型的＆＃39; const int＆＃39;                it-＆gt; current = NULL;

在我的MtmSet.h文件的几个部分。

这些是我正在使用的文件。我真的很茫然，所以我担心我不知道哪个部分是相关的，但试图尽可能地省略。 错误行标记为粗体+下划线。

main.cpp中：

#include "MtmSet.h"

int main() {
    MtmSet<int> set;
    return 0;
}

MtmSet.h：

#ifndef MTM4_SET_H
#define MTM4_SET_H

#include <cstdlib>

namespace mtm{


    template<typename Type>
    class MtmSet{

        /**
         * A node in the set
         */
        class Node{
            Type data;
            Node* next;

        public:
            Type& getData() {
                return data;
            }
            Node getNext() {
                return *next;
            }

            Node() = default;
            explicit Node(Type data) : data(data), next(NULL) {}
        };

        Node* first;

    public:

        //Forward declaration
        class const_iterator;

        /**
         * A iterator for Set
        */
        class iterator{
            Node* current;
        public:
            /**
             * Empty constructor. Should not be dereferenced.
             * Same as MtmSet::end()
             */
            iterator() = default;

            /**
             * Constructor of Set iterator
             * @param node The node the iterator points to
             */
            explicit iterator(Node *node){
                current = node;
            }

            /**
             * Copy constructor
             * @param it The iterator to copy
             */
            iterator(const iterator& it){
                *this = it;
            }

            /**
             * Destructor
             */
            ~iterator() = default;

            iterator& operator=(const iterator& rhs){
                current = rhs.current;

                return *this;
            }

            const Type& operator*() const{
                return current->getData();
            }

            const Type *operator->() const{
                return current->getData();
            }

            iterator& operator++(){
                *current = current->getNext();
                return *this;
            }

            iterator operator++(int){
                iterator it = *this;
                *current = current->getNext();
                return it;
            }

            bool operator==(const const_iterator& rhs) const{
                if (current == rhs.current) {
                    return true;
                }
                return false;
            }

            bool operator!=(const const_iterator& rhs) const{
                return !(current == rhs.current);
            }

            friend class const_iterator;
        };

        iterator it;
        const_iterator const_it;

        /**
         * Empty constructor
         * Creates an empty set
         */
        MtmSet() : first(NULL){

第一个错误 - ＆gt; current = NULL，const_it-＆gt; current = NULL， 而所有其他行返回相同的错误：

            it->current = NULL;
            const_it->current = NULL;
        }

        /**
         * Copy constructor
         * @param set the Set to copy
         */
        MtmSet(const MtmSet& set){}

        /**
         * Destructor
         * Free all allocated memory in the set.
         */
        ~MtmSet() = default;

        iterator insert(const Type& elem){
            Node *a = new Node(elem);
            if (first == NULL) {
                first = a;
                const_it->current = a;
                it->current = a;
                return it;
            }

            if (contains(elem)) {
                return it;
            }

            while (it->current->next != NULL) {

                it->current = it->current->next;
            }
            it->current->next = a;
            it->current = it->current->next;

            return it;
        }

        iterator find(const Type& elem){}

        const_iterator find(const Type& elem) const{
            it->current = first;

            while (it->current != NULL) {
                if (it->current->data == elem) {
                    return it;
                }
            }
            return NULL;
        }

        bool contains(const Type& elem) const{
            if (find(elem)) {
                return true;
            }
            return false;
        }
    };
} // namespace mtm

#endif //MTM4_SET_H

非常感谢任何帮助。