параметры шаблона

#include <iostream>
#include <exception>
#include <stdexcept>
#include <cstdlib>
#include <ctime>
#include <string>
 
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;
        }
        int find(const value_type& what, bool (*compare)(const value_type& a, const value_type& b), int start=0) const
        {
                for (int i=start; i<_size; i++)
                        if (compare(at(i), what))
                                return i;
                return -1;
        }
 
        void randomize()
        {
            if (size()<2)
                return;
            value_type tmp;
            for (int i=0; i<size(); i++)
            {
                int r = rand() % size();
                tmp = at(i);
                node(i)->_data = at(r);
                node(r)->_data = tmp;
            }
        }
        
        ~List()
        {
                clear();
        }
};
 
class Composition
{
    string _name;
    int _length;
public:
    Composition() : _name(""), _length(0) {};
    Composition(string aName, int aLength) : _name(aName), _length(aLength) {}
    string& name() { return _name;  }
    int& length() { return _length; }
    friend ostream& operator<<(ostream& o, Composition& c)
    {
        o << c.name() << " - " << c.length()/360 << ":" << (c.length() % 360)/60 << ":" << c.length()%60; 
        return o;
    }
};
 
class Player
{
    typedef List<Composition> PlayList;
    PlayList _playlist;
    int _current_track_number;
public:
    Player() : _current_track_number(-1) {}
    void add_track(const Composition& composition)
    {
        _playlist.push_back(composition);
    }
    void add_track(string name, int length)
    {
        Composition composition(name, length);
        _playlist.push_back(composition);
    }
    void remove_track(int n)
    {
        _playlist.remove(n);
    }
    void randomize()
    {
        _playlist.randomize();
    }
    int size() const { return _playlist.size(); }
    Composition current_track() const 
    {
        if (_current_track_number<size() && _current_track_number>0)
            return _playlist[_current_track_number]; 
        Composition r("nothing", 0);
        return r;
    }
    Composition& track(int n) { return _playlist[n]; }
    Composition& track(int n) const { return _playlist[n]; }
    friend ostream& operator<<(ostream& o, const Player& player)
    {
        
        for (int i=0; i<player.size(); i++)
            o << i << ". " << player.track(i) << endl;
        o << "Now playing: " << player.current_track().name() << endl;
        return o;
    }
    void play(int n)
    {
        if (n<_playlist.size() && n>-1)
            _current_track_number = n;
        else
            _current_track_number = -1;
        cout << "Now playing: " << current_track().name() << endl;
    }
    void stop()
    {
        _current_track_number = -1;
        cout << "Now playing: " << current_track().name() << endl;
    }
};
 
int main(int argc, char* argv[])
{
    Player player;
    player.add_track("Bethoven - Fur Elise", 365);
    player.add_track("Bethoven - Valdstein", 217);
    player.add_track("Bethoven - Kreutzer", 412);
 
    cout << player;
    bool done = false;
    int choice;
    while (!done)
    {
        cout << "Menu:" << endl;
        cout << "1. Play..." << endl;
        cout << "2. Stop" << endl;
        cout << "0. Quit" << endl;
        cout << "Choice: "; cin >> choice;
        switch (choice)
        {
        case 0:
            done = true;
            break;
        case 1:
            cout << "Select track number: ";
            cin >> choice;
            player.play(choice);
            break;
        case 2:
            player.stop();
            break;
        }
    }
    
    return 0;
}