C++ c++；重新定义运算符<；（）还有接线员=()

我有一个队列的实现：

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

#包括
使用名称空间std；
模板
结构元素
{
T-inf；
元素链接；
};
模板
类队列
{
公众：
队列（）；
~Queue（）；
队列（const Queue&）；
队列和运算符=（常量队列&）；
bool empty（）常量；
无效推力（常数T&）；
无效pop（T&）；
空压头（T&）常数；
作废打印（）；
int length（）；
私人：
elem_q*正面；
elem_q*后部；
无效复制队列（const队列）；
void deleteQueue（）；
};
模板
队列：：队列（）
{
前=后=零；
}
模板
队列：：~Queue（）
{
deleteQueue（）；
}
模板
队列：：队列（常量队列&r）
{
复制队列（r）；
}
模板
队列和队列：：运算符=（常量队列和r）
{
如果（此！=&r）
{
deleteQueue（）；
复制队列（r）；
}
归还*这个；
}
模板
无效队列：：复制队列（常量队列r）
{
前=后=零；
elem_q*p=右前；
while（p）
{
推送（p->inf）；
p=p->link；
}
}
模板
无效队列：：删除队列（）
{
tx；
而（！empty（））
{
pop（x）；
}
}
模板
bool队列：：empty（）常量
{
返回后==NULL；
}
模板
无效队列：：推送（常量T&x）
{
elem_q*p=新的elem_q；
p->inf=x；
p->link=NULL；
如果（后）后->链接=p；
else-front=p；
后部=p；
}
模板
无效队列：：pop（T&x）
{
if（空（））
{
coutlink；
删除q；
}
}
模板
无效队列：：头（T&x）常量
{
if（空（））
{
看你是如何做到这一点的：

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

模板
队列和队列：：运算符=（常量队列和r）
{
如果（此！=&r）
{
deleteQueue（）；
复制队列（r）；
}
归还*这个；
}

还要重载您需要的其他运算符。
好吧，逻辑运算符具有预期的语法，如下所示：

然而，我必须注意两件事：


首先，您真的需要再次检查类的设计->引用的使用中存在大量的不一致，奇怪的API，我甚至不知道
minqueue
到底应该做什么，或者更确切地说，它为什么这样做
第二，若您想让队列自排序，从最小元素开始，诸如此类，您应该查找优先级队列或堆
模板
结构元素
{
T-inf；
元素链接；
};
模板
bool运算符。您需要重载运算符<和！=不是针对队列类，而是针对存储在容器中的类实例。我还将添加关于破坏性
length（）
和
print（）的注释
。这看起来不错，但为什么这3个函数仍然不起作用。当我运行它时，我发现按摩示例.exe已经停止工作…所以我的程序是killed@user3050163我不认为运算符有问题。我认为原因在于您的代码。@user3050163您的代码中有很多很多问题，所以您可能应该首先更好地理解一下。请看我的答案，找到一些开始的地方。@Vladfromoscow aaa我很抱歉，我可能过早地得出了结论。（出于某种原因，我忽略了它们是自由函数而不是成员函数的部分。）--我将删除注释。
  bool ClassName::operator!=(const ClassName& other) const {
      return //compare as apropriate.
  }

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