std::vector<int> x;
//...
std::sort(x.begin(),x.end(),x_compare);

template<typename TContainer>
void sort(TContainer& c);

__>Чем аргументираванно такое поведение ?

Алгоритмы (sort, stable_sort) не могут использоваться со списками, потому что списки не поддерживают итераторы свободного доступа. Впрочем, для сортировкиэлементов в списках определена специальная функция sort()

template<class V, class A, class P>
void sort_container(std::vector<V,A>& cont, P pred)
{
  std::sort(cont.begin(), cont.end(), pred);
}

template<class V, class A, class P>
void sort_container(std::list<V,A>& cont, P pred)
{
  cont.sort(pred);
}

template<class C>
void sort_container(C& cont)
{
  sort_container(cont, std::less<typename C::value_type>());
}

template<class Cont>
void Sort(Cont &);

template<class T>
void Sort(list<T> &);//допустим, вижуал 6.0 не сможет определить кто из функций лучше подходит, но это
//уже дело десятое

__>template<typename TContainer>
__>void sort(TContainer& c);
__>

int a[10];
std::sort(a, a+10);

A>int a[10];
A>std::sort(a, a+10);
A>

/// Array reference.
template<class ValueType>
class array_ref: 
{
public:
    template<int Size>
    array_ref(ValueType (&X)[Size]): Begin(X), End(X+Size) {}

    // здесь интерфейсы контейнера, такие как typedef ... iterator, iterator begin() и т.д. ...
    ...
private:
    ValueType *Begin;
    ValueType *End;
};

/// Creates an array reference.
template<class ValueType, int Size>
array_ref<ValueType> make_array_ref(ValueType (&X)[Size]) 
{ 
    return array_ref<ValueType>(X); 
}

int a[10];
std_ex::sort(make_array_ref(a));

template<typename TContainer>
class C
{
 TContainer c;
public:
 void sort()
 {
  std::sort_container(c);
 }
};

_>Это легко лечиться классом оболочкой, которая содержит в себе пару итераторов

_>/// Array reference.
_>template<class ValueType>
_>class array_ref: 
_>

_>int a[10];
_>std_ex::sort(make_array_ref(a));
_>

std::vector<int> vector(2000);

// заполняем

std::sort(vector.begin(), vector.end());
int prev_size=vector.size();

for(int index=0; index<200; ++index) 
  vector.push_back(some_value());

std::sort(vector.begin()+prev_size, vector.end()); // как быть сдесь

std::inplace_merge(vector.begin(), vector.begin()+prev_size, vector.end());

template<class It, class Pred>
std::pair<It,size_t> dummy_partition(It begin, It end, Pred pred)
{
  if(begin == end) return std::make_pair(begin,0);

  It splitter = begin;
  It it = splitter; ++it;
  // invariant: [begin,splitter) < [splitter] < (splitter,it)
  size_t d = 0; // == distance(begin,splitter)

  while(it != end)
  {
    if(!pred(*splitter, *it)) // *splitter >= *it
    {
      swap(*splitter,*it);
      ++splitter; ++d;
    }
    ++it;
  }

  return std::make_pair(splitter,d);
}

template<class It, class Pred>
void dummy_sort_imp(It begin, It end, size_t size, Pred pred)
{
  while(size > 1)
  {
    // разбиваем интервал на два, с центральным элементом
    std::pair<It,size_t> part = dummy_partition(begin,end,pred);

    It end1 = part.first;
    It begin2 = end1; ++begin2;
    size_t size1 = part.second;
    size_t size2 = size-size1-1;

    // рекурсивно спускаемся в меньший из интервалов (оставляя больший для следующей итерации)
    if(size1*2 <= size)
    {
      dummy_sort(begin, end1, size1, pred);
      begin = begin2;
      size = size2;
    }
    else
    {
      dummy_sort(begin2, end, size2, pred);
      end = end1;
      size = size1;
    }
  }
}

template<class It, class Pred>
void dummy_sort(It begin, It end, Pred pred)
{
  // вычисляем размер интервала единожды (требуется O(N) инкрементов итератора)
  dummy_sort_imp(begin, end, std::distance(begin,end), pred);
}

std::vector<int> vector(2000);

// заполняем

std_ex::sort(vector);
int prev_size=vector.size();

for(int index=0; index<200; ++index) 
  vector.push_back(some_value());

std_ex::sort(make_sequence(vector.begin()+prev_size, vector.end())); // использовать оболочку sequence

std_ex::inplace_merge(vector, vector.begin()+prev_size); // здесь middle указываеться в конце.

_>std::vector<int> vector(2000);

_>// заполняем

_>std_ex::sort(vector);
_>int prev_size=vector.size();

_>for(int index=0; index<200; ++index) 
_>  vector.push_back(some_value());

_>std_ex::sort(make_sequence(vector.begin()+prev_size, vector.end())); // использовать оболочку sequence

_>std_ex::inplace_merge(vector, vector.begin()+prev_size); // здесь middle указываеться в конце.
_>

#define begin_end(c) c.begin(), c.end()

std::vector<int> x;
std::sort(begin_end(x));

_>>Согласен, но у меня просто аллергия на дефайны .

__>Почему ?

#define begin_end(c) c.begin(), c.end()

bool y;
std::vector<int> x, y;
std::sort(begin_end(flag ? x: y));

_>>>Согласен, но у меня просто аллергия на дефайны .

__>>Почему ?

_>#define begin_end(c) c.begin(), c.end()

_>bool y;
_>std::vector<int> x, y;
_>std::sort(begin_end(flag ? x: y));
_>

_>Кому как, для меня важнее надежность и понятность кода .

#define begin_end(c) (c).begin(), (c).end()

O>class Temp
O>{
O>    public:
O>    char s[50];
O>    int age;
        
O>    Temp();                                             
O>    Temp(const Temp &T);                                
O>    Temp(char t_s[50],int t_age);
O>    ~Temp();
O>};

bool less_name_fn(const Temp& l, const Temp& r); // по полю s
bool less_age_fn (const Temp& l, const Temp& r); // по полю age

struct less_name { bool operator()(const Temp& l, const Temp& r) const { return less_name_fn(l,r); } };

typedef std::set<Temp, less_name> temps_by_name;


struct less_ptr_age { bool operator()(const Temp* l, const Temp* r) const { return less_age_fn(*l,*r); } };

void print_by_age(const temps_by_name& temps)
{
  tyepdef std::vector<Temp*> temp_ptrs_by_age;
  temp_ptrs_by_age v; v.reserve(temps.size());

  for(temps_by_name::const_iterator i = temps.begin(); i!=temps.end(); ++i)
    v.push_back(&*i);

  std::stable_sort(v.begin(), v.end(), less_ptr_age()); // ещё и порядок имён сохраним

  for(temp_ptrs_by_age::const_iterator j = v.begin(); j!=v.end(); ++j)
    cout << (*j).s << " : " << (*j).age << endl;
}