template <class T>
void mysort (T *const array ,int from ,int to) {
	if (from >= to)
		return ;
	int i = from ;
	int j = to ;
	T tmp = std::move (array[i]) ;
	while (true) {
		while (i < j && tmp < array[j])
			j-- ;
		if (i >= j)
			break ;
		array[i++] = std::move (array[j]) ;
		while (i < j && array[i] < tmp)
			i++ ;
		if (i >= j)
			break ;
		array[j--] = std::move (array[i]) ;
	}
	array[i] = std::move (tmp) ;
	mysort (array ,from ,i - 1) ;
	mysort (array ,j + 1 ,to) ;
}
/////////////////////////////////////////////////////////////////
#include <functional>
#include <new>
template <class T>
void mysort (T *const array ,int from ,int to ,const std::function<bool (const T & ,const T &)> &less) {
	static const std::function<bool (const T & ,const T &)> *const pless = &less ;
	struct EXT {
		char unused[sizeof (T)] ;
		inline EXT (EXT &&r) { new (this) T (std::move (reinterpret_cast<T &> (r))) ;}
		inline EXT &operator= (EXT &&r) { reinterpret_cast<T &> (*this) = std::move (reinterpret_cast<T &> (r)) ; return *this ; }
		inline bool operator< (const EXT &r) const { return (*pless) (reinterpret_cast<const T &> (*this) ,reinterpret_cast<const T &> (r)) ; }
	} ;
	mysort<EXT> ((EXT *) array ,from ,to) ;
}
#include <iostream>
#include <algorithm>
using namespace std ;
int main () {
	const int a[] = {1 ,3 ,3 ,2 ,4 ,1} ;
	int b[__crt_countof (a)] ;
	for (int i = 0 ; i < __crt_countof (a) ; i++)
		b[i] = i ;
	mysort<int> (b ,0 ,__crt_countof (a) - 1 ,std::bind ([] (const int &rl ,const int &rr ,const int *arr) {
		return arr[rl] < arr[rr] ;
	} ,std::placeholders::_1 ,std::placeholders::_2 ,(const int *) a)) ;
	for (int i = 0 ; i < __crt_countof (a) ; i++)
		cout << a[b[i]] << " " ;
	return 0 ;
}

想重用最上面的sort来做外部排序
按理说c++运行的时候应该会记录当前函数的栈帧，那为什么EXT不能直接访问less呢
现在用个静态变量传递less，貌似这样写会有多线程同步问题
加锁或threadlocal会严重影响效率吗，怎样实现比较好