Зачетная неделя, а у меня только одна лаба сдана. всему виной абстрактные типы данных((сделать лабу.

#define NULL 0
 
template<class _Tp>
class list {
    private:
        class node {
            public:
                node* next_;
                _Tp data_;
                node() :  next_(NULL) {}
                explicit node(_Tp value) : next_(NULL), data_(value) {}
        };
        node* find_node(int position) {
            node* temporary = start_;
            for (int i = 0; i < position; i++)
                temporary = temporary->next_;
            return temporary;
        }
        node* start_;
        unsigned int size_;
    public:
        typedef _Tp value_type;
        typedef _Tp* value_pointer;
        list();
        ~list();
        value_type& at(unsigned int position);
        void clear();
        void erase(unsigned int position);
        void insert(unsigned int position, const value_type& value);
        void push_back(const value_type value);
        unsigned int size() const;
};

template<class _Tp>
list<_Tp>::list()
    : start_(NULL), size_(0) {
}
 
template<class _Tp>
list<_Tp>::~list() {
    erase();
}
 
template<class _Tp>
_Tp& list<_Tp>::at(unsigned int position) {
    return find_node(position)->data_;
}
 
template<class _Tp>
void list<_Tp>::clear() {
    value_pointer temporary;
    while (start_ != NULL) {
        temporary = start_->next_;
        delete start_;
    }
    size_ = 0;
}
 
template<class _Tp>
void list<_Tp>::erase(unsigned int position) {
    node* node_to_delete;
    if (position == 0) {
        node_to_delete = start_;
        start_ = start_->next_;
        delete node_to_delete;
    } else {
        node_to_delete = find_node(position);
        node* previous_node = find_node(position-1);
        previous_node->next_ = node_to_delete->next_;
        delete node_to_delete;
    }
    size--;
}
 
template<class _Tp>
void list<_Tp>::insert(unsigned int position, const value_type& value) {
    node* new_node = new node(value);
    if (position == 0) {
        new_node->next_ = start_;
        start_ = new_node;
    } else {
        node* previous_node = find_node(position-1);
        new_node->next_= previous_node->next_;
        previous_node->next_ = new_node;
    }
    size_++;
}
 
template<class _Tp>
void list<_Tp>::push_back(const value_type& value) {
    insert(size_, value);
}
 
template<class _Tp>
unsigned int list<_Tp>::size() const {
    return size_;
}
 
int main(int argc, char* argv[]) {
    return 0;
}