模板类 template <class T> sort

/********************************************
模板类	template <class T>
队列从中间开始（５）插入若干元素，并对其进行升序排列
队列为循环队列,队列长度为１０
********************************************/
#include <iostream>
using namespace std;

template <class T>
class xqueue{
public:
xqueue();
void enqueue(T item);
void sort(T *num, int len);
void print()const;
T *getdata(){
return data;
}
private:
T data[10];
int head;
int tail;
};

template <class T>
//xqueue<T>::xqueue():head(5),tail(5){}
xqueue<T>::xqueue()
{
head = 5;
tail = 5;
}

template <class T>
void xqueue<T>::enqueue(T item){
data[tail] = item;
tail = (tail +1)%10;
}

template <class T>
void xqueue<T>::print()const{
for(int i = head; i != tail; i=(i+1)%10){
data[i].print();
}
}

class RN{
public:
RN(int _x, int _y);
bool operator >(RN rn)const;
void print()const;
private:
int x;
int y;
};
RN::RN(int _x = 1, int _y = 1):x(_x),y(_y){}

bool RN::operator>(RN rn)const{
return x/(double)y > rn.x/(double)rn.y;
}
void RN::print()const{
cout << x << "/" << y << endl;
}

class xpoint{
public:
xpoint(int _x, int _y);
bool operator >(xpoint xp)const;
void print()const;
private:
int x, y;
};

xpoint::xpoint(int _x = 0, int _y = 0):x(_x),y(_y){}

bool xpoint::operator >(xpoint xp)const{
//	return (x^2 + y^2) > (xp.x^2 + xp.y^2);　//错误
return (x^2) + (y^2) > (xp.x^2) + (xp.y^2);//ok
//	return (x*x + y*y) > (xp.x*xp.x + xp.y*xp.y); //ok
}

void xpoint::print()const{
cout << "(" << x << "," << y << ")" << endl;
}

template <class T>
void print_array(T *buf, int len)
{
T tmp;
for(int i = 0; i < len; i++){
buf[i].print();
}
}

template <class T>
void xqueue<T>::sort(T *num, int len)
{
int i, j;
T tmp;
for(i = 0; i < len; i++){
//      for(j = 0; j < len - i - 1; j++){
for(j = head; j != (tail - 1) ; j = (j+1)%10){  //是　j != (tail - 1)
if(num[j] > num[(j + 1)%10]){   //注意是num[j] and num[j + 1]
tmp = num[(j + 1)%10];
num[(j + 1)%10] = num[j];
num[j] = tmp;
}
}
}
}
#if 0
template <class T>
void sort(T *a, size_t len){
T t;
for(int i=0;i<len-1;i++) /* 冒泡法排序 */
for(int j=0;j<len-i-1;j++)
if(a[j]>a[j+1]) {
t=a[j];/* 交换a[i]和a[j] */
a[j]=a[j+1];
a[j+1]=t;
}
}
#endif

int main(){
xqueue<RN> q1;
q1.enqueue(RN(1,2));
q1.enqueue(RN(4,2));
q1.enqueue(RN(4,2));
q1.enqueue(RN(1,2));
q1.enqueue(RN(8,3));
q1.enqueue(RN(8,3));
q1.sort(q1.getdata(),6);
q1.print();
cout << "----------------------" << endl;
xqueue<xpoint> q2;
q2.enqueue(xpoint(2,2));
q2.enqueue(xpoint(5,3));
q2.enqueue(xpoint(6,6));
q2.enqueue(xpoint(1,6));
q2.enqueue(xpoint(4,2));
q2.enqueue(xpoint(4,2));
q2.sort(q2.getdata(),6);
q2.print();

}

/*$ ./a.out
1/2
1/2
4/2
4/2
8/3
8/3
----------------------
(2,2)
(4,2)
(4,2)
(1,6)
(5,3)
(6,6)
*/