класс-список

#include <iostream>
#include <exception>
#include <stdexcept>
#include <cstdlib>
#include <ctime>
 
using namespace std;
 
template <class _Tp>
class List
{
protected:
        typedef _Tp value_type;
        typedef value_type* pointer;
 
        class _list_node_base
        {
        public:
                _list_node_base* _next;
                value_type _data;
        };
 
        _list_node_base* _start;
        int _size;
 
        _list_node_base* node(int n)
        {
                _list_node_base* _tmp = _start;
                for (int i=0; i<n; i++)
                        _tmp = _tmp->_next;
                return _tmp;
        }
 
public:
        List(void) : _start(0), _size(0) {}
        List(const List& other)
        {
                List();
                clear();
                append(other);
        }
 
        virtual void append(const List& other)
        {
                for (int i=0; i<other.size(); i++)
                        push_back(other[i]);
        }
 
        virtual void push_back(const value_type& data)
        {
                _list_node_base* _new = new _list_node_base;
                _new->_data = data;
                _new->_next = 0;
                if (_start == 0)
                {
                        _start = _new;
                }
                else
                {
                        _list_node_base* _end = node(size()-1);
                        _end->_next = _new;
                }
                _size++;
        }
 
        virtual void insert(const int n, const value_type& data)
        {
                if (n > _size)
                        throw out_of_range("List index out of bounds.");
                if (n == _size)
                        push_back(data);
                else
                {
                        _list_node_base* _new = new _list_node_base;
                        _new->_data = data;
                        _new->_next = 0;
                        if (n == 0)
                        {
                                _new->_next = _start;
                                _start = _new;
                        }
                        else
                        {
                                _list_node_base* _tmp = node(n-1);
                                _new->_next = _tmp->_next;
                                _tmp->_next = _new;
                        }
                        _size++;
                }
        }
 
        void remove(int n)
        {
                if (n>=size())
                        throw out_of_range("List index out of bounds.");
                _list_node_base* _this_node;
                if (n==0)
                {
                        _this_node = _start;
                        _start = _this_node->_next;
                }
                else
                {
                        _list_node_base* _prev_node = node(n-1);
                        _this_node = _prev_node->_next;
                        _prev_node->_next = _this_node->_next;
                }
                delete _this_node;
                _size--;
        }
 
        int size() const { return _size; }
 
        value_type& at(int n) const
        {
                _list_node_base* _tmp = _start;
                for (int i=0; i<n; i++)
                        if (_tmp!=0)
                                _tmp = _tmp->_next;
                if (_tmp!=0)
                        return _tmp->_data;
                else
                        throw out_of_range("List index out of bounds.");
        }
 
        value_type& operator[](int n) { return at(n); }
        value_type& operator[](int n) const { return at(n); }
        friend ostream& operator<< (ostream& o, const List<value_type>& l)
        {
                for(int i=0; i<l.size(); i++)
                        o << l[i] << " ";
                return o;
        }
 
        void clear()
        {
                _list_node_base* _tmp;
                while (_start!=0)
                {
                        _tmp = _start->_next;
                        delete _start;
                        _start=_tmp;
                }
                _size = 0;
        }
 
        List<value_type>& operator= (const List<value_type>& other)
        {
                if (this!=&other)
                {
                        clear();
                        append(other);
                }
        }
 
        int find(const value_type& what) const
        {
                for (int i=0; i<_size; i++)
                        if (at(i) == what)
                                return i;
                return -1;
        }
        ~List()
        {
                clear();
        }
};
 
int main()
{
        srand(static_cast<unsigned int>(time(0)));
        List<int> a;
        List<int> b;
 
        int n;
        cout << "Input n: ";
        cin >> n;
 
        for (int i=0; i<n; i++)
                a.push_back(rand()%11-5);
        cout << "Array a: " << a << endl;
 
        for (int i=0; i<n; i++)
                b.push_back(rand()%11-5);
        cout << "Array b: " << b << endl;
 
        int e;
        cout << "Input e: ";
        cin >> e;
        int e_position = a.find(e)+1;
        cout << a.at(0) << a[0] << " " << e_position << endl;
        if (e_position > 0)
                for (int i=0; i<b.size(); i++)
                        a.insert(e_position+i, b[i]);
        cout << "Array a: " << a << endl;
 
        return 0;
}