Перегрузка оператора индексации в списке

class container
{    
   friend ostream &operator<<(ostream &o, container &cont){o<<cont.ink.tem; o<<std::endl;}
      
    public:   
    struct link
    {
        int item;
        link *prev;
        link *next;
        link(int value, link *pr=NULL, link *ne=NULL){item=value,prev=pr,next=ne;}
    };
   
    int counter;
    
    link *first;
    link *last;
 
    int &operator[](int); 
 
...
};
 
int& container::operator[](int count)
{
    link *mylink=first;
    
    for (int i=0; i<count; i++)
    mylink=mylink->next;
    
    return mylink->item;
} 
 
...
 
main()
{
container *tt=new container();
    tt->add_item(45); 
    tt->add_item(1);
 
cout<<tt[1];

#include <iostream>
 
template <typename T>
class List
  {
    template <typename U>
    friend std::ostream& operator<<(std::ostream& out, const List<U>& list);
 
    struct Node
      {
      Node() : next(0), prev(0) {}
 
      T data;
      Node *next;
      Node *prev;
      };
 
  public:
    List();
 
    void push_back(const T& data);
    
    T& operator[] (int index);
 
  private:
    Node *head;
    Node *curr;
  };
 
template <typename T>
List<T>::List() : head(0), curr(0) {}
 
template <typename T>
void List<T>::push_back(const T& data)
{
  Node *node = new Node();
  if (!head)
    {
    head = node;
    }
  else
    {
    node->prev = curr;
    curr->next = node;
    }
 
  curr = node;
  curr->data = data;
}
 
template <typename T>
T& List<T>::operator[] (int index)
  {
  Node *node = head;
  for (int i = 0; i < index; ++i)
    node = node->next;
 
  return node->data;
  }
 
template <typename T>
std::ostream& operator<<(std::ostream& out, const List<T>& list)
  {
  for (List<T>::Node *node = list.head; node != 0; node = node->next)
    out << node->data << " ";
  return out;
  }
 
int main()
  {
  List<int> list;
 
  list.push_back(1);
  list.push_back(2);
  list.push_back(3);
 
  list[2] = 42;
 
  std::cout << list << std::endl;
  std::cin.get();
 
  return 0;
  }

int &operator[](int);

int SumOfElements(my_list const &List);

int         operator [](size_t Index);          // Обычная версия.
int const & operator [](size_t Index) const;    // const-версия.