Перегрузка индексного оператора для шаблонного класса

#include <iostream>
 
    using namespace std;
 
template <typename T>
    struct Node {
        T key;
        Node* next;
    };
 
template <class T>
    class vec {
        
        private:
 
            Node<T>* head;
 
        public:
 
            void add(T);
            //Node<T>* remove(T);
            //Node<T>* sort_inc();
            //Node<T>* sort_dec();
            //int size();
            void print();
 
        vec() {
                head = NULL;
            }
 
            ~vec() {
                while (head != NULL) {
                    Node<T>* temp = head->next;
                    delete head;
                    head = temp;
                }
            }
    };
 
template <typename T>
    void vec<T>::add(T key) {
        Node<T>* temp = new Node<T>;
        temp->key = key;
        temp->next = NULL;
        if (head == NULL) {
            head = temp;
        } else {
            Node<T>* ptr = head;
            while (ptr->next != NULL) {
                ptr = ptr->next;
            }
            ptr->next = temp;
        }
    }
 
template <typename T>
    void vec<T>::print() {
        if (head != NULL) {
            Node<T>* curr = head;
            while (curr != NULL) {
                cout << curr->key << " ";
                curr = curr->next;
            }
        } else {
            cout << "Empty!\n";
        }
    }
    
template <typename T>
    int vec<T>::size() {
        Node<T>* curr = head;
        int k = 0;
        while (curr != NULL) {
            k++;
            curr = curr->next;
        }
        return k;
    }
 
int main() {
    int n;
    vec<int> v;
    v.add(1);
    v.add(2);
    cout << v[0] << "\n";
    return 0;
}

private:
  T& at_pos (size_t pos)
  {
 
            Node<T>* curr = head;
    for (int i = 0; i < pos && curr; i++) {
        curr = curr->next;
    }
    if (curr) {
        return curr->key;
    }
    throw std::out_of_range("out of range");
}
public:
T& operator[](size_t pos)
{
    return at_pos(pos);
}
 
const
T& operator[](size_t pos)const
{
    return at_pos(pos);
}