模板类 template sort

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

/********************************************
模板类	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)
*/