C++重新定義運算符<（）和operator =（）

Question

我有這樣的執行隊列：！

#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; 
} 

我如何重新定義運營商<和=因爲沒有他們的功能minqueue，Sortqueue和合並不工作？請幫幫我.............................................. 。

Answer 1

看你怎麼已經這樣做：

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

超載您需要的其他運營商，T OO。

Answer 2

好，邏輯運算符有相當預期的語法，看起來像這樣：

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

不過，我要注意兩件事情：

• 首先，你真的需要去通過類再次設計 - >在使用引用，奇怪的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)); 
}