Question on operator+ overload of random access iterator, in template

I would like to overload the "+" operator of iterator in list class, something like

list<double>::iterator operator+(const list<double>::iterator& it, int n)

This works well. However, when I try to implement it as template, like

template<class T>
typename list<T>::iterator operator+(const typename list<T>::iterator& it, int n)

I got error msg like,

no match for 'operator+' in 'it + small_index'

can't figure out the reason...

The code is attached below,

#include<iostream>
#include<list>
using namespace std;

template<class T>
ostream& operator<< (ostream& os, const list<T>& l)
{
  typename list<T>::const_iterator i = l.begin();
  for (;i!=--l.end();i++)
    os<<*i<<";";
  os<<*i<<endl;
  return os;
}

template<class T> //this is where it goes WRONG.
                  //If don't use template, delete "typename", T->double, runs well
typename list<T>::iterator operator+(const typename list<T>::iterator& it, int n)
{
  typename list<double>::iterator temp=it;
  for(int i=0; i<n; i++)
    temp++;
  return temp;
}

template <class T>
void small_sort(list<T>& l)
{
  int n = l.size();
  typename list<T>::iterator it = l.begin();
  for(int i=0; i<n-1; i++)
    {
      //Find index of next smallest value
      int small_index = i;
      for(int j=i+1; j<n; j++)
    {
      if(*(it+j)<*(it+small_index)) small_index=j;
    }
      //Swap next smallest into place
      double temp = *(it+i);
      *(it+i) = *(it+small_index);
      *(it+small_index)=temp;
    }
}

int main()
{
  list<double> l;
  l.push_back(6);
  l.push_back(1);
  l.push_back(3);
  l.push_back(2);
  l.push_back(4);
  l.push_back(5);
  l.push_back(0);

  cout<<"==========开发者_运维技巧===sort the list=============="<<endl;
  small_sort(l);
  cout<<l;
  return 0;
}

The problem is that the argument is not deducible in that context.

template<class T>
typename list<T>::iterator operator+(const typename list<T>::iterator& it, int n);

When you use an iterator there, the compiler would have to generate all possible instantiations of list with any given type, and try to match an internal type iterator with the argument that you are passing, note that the set of all types is actually infinite once you add templates to the mix, as you can instantiate a template with an instantiation of the same template ad infinitum.

I recommend that you avoid the problem altogether and use std::advance which is the idiomatic way of advancing an iterator.

You should take a look whether the standard algorithm std::advance(it, n) could be used. It's defined in <iterator>. It does "the right thing" for any suitable iterator.