C++ 연산자 <()와 연산자를 재정의 =()

Question

나는 큐의 구현이 :! = 때문에 기능 minqueue, Sortqueue 그들없이

#include<iostream> 
using namespace std; 

template <typename T> 
struct elem_q 
{ 
T inf; 
elem_q<T>* link; 
}; 

template <typename T = int> 
class Queue 
{ 
public: 
    Queue(); 
    ~Queue(); 
    Queue(const Queue&); 
    Queue& operator= (const Queue&); 

    bool empty()const; 
    void push(const T&); 
    void pop(T&); 
    void head(T&) const; 
    void print(); 
    int length(); 

    private: 
    elem_q<T> *front; 
    elem_q<T> *rear; 

    void copyQueue(const Queue<T>); 
    void deleteQueue(); 
}; 

template <typename T> 
Queue<T>::Queue() 
{ 
front = rear = NULL; 
} 

template <typename T> 
Queue<T>::~Queue() 
{ 
    deleteQueue(); 
} 

template <typename T> 
Queue<T>::Queue(const Queue<T>& r) 
{ 
copyQueue(r); 
} 

template <typename T> 
Queue<T>& Queue<T>::operator=(const Queue<T>& r) 
{ 
if(this != &r) 
{ 
    deleteQueue(); 
    copyQueue(r); 
} 
return *this; 
} 

template <typename T> 
void Queue<T>::copyQueue(const Queue<T> r) 
{ 
front = rear = NULL; 
elem_q<T> *p = r.front; 
while(p) 
{ 
    push(p->inf); 
    p = p->link; 
} 
} 

template <typename T> 
void Queue<T>::deleteQueue() 
{ 
T x; 
while (!empty()) 
{ 
    pop(x); 
} 
} 

template <typename T> 
bool Queue<T>::empty() const 
{ 
return rear == NULL; 
} 

template <typename T> 
void Queue<T>::push(const T& x) 
{ 
elem_q<T> *p = new elem_q<T>; 
p->inf = x; 
p->link = NULL; 
if (rear) rear->link = p; 
else front = p; 
rear = p; 
} 

template <typename T> 
void Queue<T>::pop(T& x) 
{ 
if(empty()) 
{ 
    cout<<"The queue is empty.\n"; 
} 
else 
{ 
    elem_q<T> *q = front; 
    x = q->inf; 
    if (q == rear) 
    { 
     rear = NULL; 
     front = NULL; 
    } 
    else front = q->link; 
    delete q; 
} 
} 

template <typename T> 
void Queue<T>::head(T& x) const 
{ 
if(empty()) 
{ 
    cout<<"The queue is empty.\n"; 
} 
else 
{ 
    x = front->inf; 
} 
} 

template <typename T> 
void Queue<T>::print() 
{ 
T x; 
while(!empty()) 
{ 
    pop(x); 
    cout<<x<<" "; 
} 
cout<<endl; 
} 

template <typename T> 
int Queue<T>::length() 
{ 
T x; 
int n = 0; 
while(!empty()) 
{ 
    pop(x); 
    n++; 
} 
return n; 
} 
template<typename T> 
void minqueue(Queue<T> q,T& min,Queue<T>& newq) 
{ 
T x; 
q.pop(min); 
while (!q.empty()) 
{ 
    q.pop(x); 
    if (x < min) 
    { 
     newq.push(min); 
     min = x; 
    } 
    else newq.push(x); 
} 

} 
template<typename T> 
void sortQueue(Queue<T> q,Queue<T>& newq) 
{ 
while(!q.empty()) 
{ 
    T min; 
    Queue<T> q1; 
    minqueue(q , min ,q1); 
    newq.push(min); 
    q = q1; 
} 

} 
template<typename T> 
Queue<T> merge(Queue<T> p,Queue<T> q,const T& dummy) 
{ 
p.push(dummy); 
q.push(dummy); 
Queue<T> r; 
T x,y; 
p.pop(x); 
q.pop(y); 
while (!p.empty() && !q.empty()) 
    if (x < y) 
    { 
     r.push(x); 
     p.pop(x); 
    } 
    else 
    { 
     r.push(y); 
     q.pop(y); 
    } 
if (!p.empty()) 
    do 
    { 
     r.push(x); 
     p.pop(x); 
    }while (x != dummy); 
else 
    do 
    { 
     r.push(y); 
     q.pop(y); 
    }while (y != dummy); 
    return r; 
} 

어떻게 내가 다시 정의 할 수 있습니다 운영자 <와 작동하지 않는 병합 도와주세요 .............................................. .

Answer 1

이미이 어떻게했는지를 참조하십시오 :

template <typename T> 
Queue<T>& Queue<T>::operator=(const Queue<T>& r) 
{ 
    if(this != &r) 
    { 
     deleteQueue(); 
     copyQueue(r); 
    } 
    return *this; 
} 

과부하 당신이 필요로하는 다른 연산자를 t 너.

bool ClassName::operator!=(const ClassName& other) const { 
     return //compare as apropriate. 
    } 

는 그러나, 나는 두 가지를주의해야 :

Answer 2

글쎄, 논리 연산자는 다음과 같이보고, 오히려 예상 구문이

• 첫째, 당신은 정말 클래스를 통해 갈 필요가 다시 디자인 -> 참고, 괴괴 망측 한 API의 사용에 야생 불일치가 있고 정확하게 정확히 minqueue이 무엇인지 확신 할 수 없거나 오히려 그것이하는 일을 왜하는지.
• 두 번째로, 자신을 정렬하는 대기열을 원한다면, 최소한의 요소 등에서 우선 순위 대기열 또는 힙을 찾아야합니다.

Answer 3

template <typename T> 
struct elem_q 
{ 
T inf; 
elem_q<T>* link; 
}; 

template <typename T> 
bool operator <(const elem_q<T> &lhs, const elem_q<T> &rhs) 
{ 
    return (lhs.inf < rhs.inf); 
} 

template <typename T> 
bool operator ==(const elem_q<T> &lhs, const elem_q<T> &rhs) 
{ 
    return (lhs.inf == rhs.inf); 
} 

template <typename T> 
bool operator !=(const elem_q<T> &lhs, const elem_q<T> &rhs) 
{ 
    return (!(lhs.inf == rhs.inf)); 
}