#include<iostream.h>
const int size=100;
class Node
{
public:
int data;
Node *next;
Node operator=(Node n);
Node operator<(Node n);
};
int ListLength(Node *p)
{
int len=0;
while(p->next!=NULL)
{
len++;
p=p->next;
}
return len;
}
Node* LocList(Node *p,int data)
{
Node *q;
q=p;
int j=0;
while(j<data)
{
q=q->next;
j++;
}
return (q);
}
int Node::operator= (Node n)
{
}
void Insert(Node number,Node *opt)
{
Node *q=new Node;
Node *cp,*ap,*t;
cp=NULL;
t=ap=opt;
q->data=number;
if(ap==NULL)
{
ap->next=q;
q->next=NULL;
}
else
while(cp!=NULL)
if(number<cp->data)break;
else
{
ap=cp;//ap永远指向的是cp的前个地址
cp=cp->next;
}
number->next=cp;
ap->next=number;
while(t!=NULL)
{
cout<<t->data<<" ";
t=t->next;
}
}
void main()
{
/*Node x,y,z;//静态建立三个节点
Node *p;
p=&x;
cout<<"输入x的data:";
cin>>x.data;
cout<<"输入y的data:";
cin>>y.data;
cout<<"输入z的data:";
cin>>z.data;
x.next=&y;
y.next=&z;
z.next=NULL;
while(p!=NULL)
{
cout<<p->data<<" ";
p=p->next;
}
cout<<endl;*/
int n;
Node *p,*q,*l,*o;//动态建立三个节点
Node node;
o=p=l=new Node;
for(int i=0;i<10;i++)
{
q=new Node;
cout<<"请输入data:";
cin>>q->data;
p->next=q;
p=q;//此时p指针指向q
}
p->next=NULL;
cout<<"当前链表的长度是:"<<ListLength(l)<<endl;
cout<<"请输入定位的数值:";
cin>>n;
cout<<LocList(l,n)<<endl;
p=l->next;//p是第一个元素节点，l是头节点
while(p!=NULL)
{
cout<<p->data<<" ";
p=p->next;
}
cout<<endl;
Insert(node,o);
}
我用了很多方法,但是编译都说是错的,只好请教大家.在这个程序里,运算符怎么重载啊?

不只是这个问题，还有几处其他问题，你把全部程序再看一遍

我试了,我把Insert函数给删除了,程序可以运行

你创建的又不是有序链表，为什么要用&lt;比较后插入呢?

你这里面对于重载的思想就有问题，首先，你想让int类型通过重载＝运算符可以等于累Node中的data成员，但是这种思想是错误的，如果Node类型的成员变量有几个int，几个char，几个string类型的话你是不是都把这几种类型的运算符重载一下，重载的思想是针对于对象级别的，q->data是数据，你让q->data = number（对象级别），这在思想上就有问题，而且由于运算符左边是int类型，所以需要重载全局操作符，但是＝并不支持被静态重载或者非成员重载，所以并不可能重载我把你的代码修改了一下，你看看符不符合你本来的想法：
[CODE]#include<iostream.h>
const int size=100;
class Node
{
public:
int data;
Node *next;
Node& operator=(Node& n);
bool operator<(Node& n);
};
int ListLength(Node *p)
{
int len=0;
while(p->next!=NULL)
{
len++;
p=p->next;
}
return len;
}
Node* LocList(Node *p,int data)
{
Node *q;
q=p;
int j=0;
while(j<data)
{
q=q->next;
j++;
}
return (q);
}
Node& Node::operator= (Node& n)
{
//将Node中除了next指针外的数据成员全部进行拷贝
return *this;
}
bool Node::operator<(Node& n)
{
return false; //比较Node类型中的大小关键字
}
void Insert(Node number,Node *opt)
{
Node *q=new Node;
Node *cp,*ap,*t;
cp=NULL;
t=ap=opt;
*q=number; //对象级别的拷贝，拷贝非next指针外的所有数据
if(ap==NULL)
{
ap->next=q;
q->next=NULL;
}
else
while(cp!=NULL)
if(number < *cp)break;
else
{
ap=cp;//ap永远指向的是cp的前个地址
cp=cp->next;
}
number=*cp;
ap->next=number.next;
while(t!=NULL)
{
cout<<t->data<<" ";
t=t->next;
}
}
void main()
{
int n;
Node *p,*q,*l,*o;//动态建立三个节点
Node node;
o=p=l=new Node;
for(int i=0;i<10;i++)
{
q=new Node;
cout<<"请输入data:";
cin>>q->data;
p->next=q;
p=q;//此时p指针指向q
}
p->next=NULL;
cout<<"当前链表的长度是:"<<ListLength(l)<<endl;
cout<<"请输入定位的数值:";
cin>>n;
cout<<LocList(l,n)<<endl;
p=l->next;//p是第一个元素节点，l是头节点
while(p!=NULL)
{
cout<<p->data<<" ";
p=p->next;
}
cout<<endl;
Insert(node,o);
}[/CODE]

Node& operator=(Node& n);
这句话是什么意思呢?为什么Node&要加上引用符号呢?

一为效率，二是因为你本身就在重载＝进行对象的拷贝，你怎么可能再在参数传递过程中对Node类型的对象进行拷贝

也就是说,此时的引用是用来进行对象拷贝的吧

no，引用其实和指针的效果差不多，lz要把基本功加强下

[CODE]#include<iostream>
using namespace std;

const int size=100;

class Node
{
private:
int data;
Node *next;

public:
Node(){ data = 0; next = NULL;}
Node(int d, Node * n)
{
data = d;
next = n;
}
Node(Node & n);
void setData(int d){ data = d;}
void setNext(Node * n)
{
next = n;
}
int getData(){return data;}
Node * getNext(){return next;}
bool operator==(const Node & n);
Node & operator=(const Node & n);
bool operator<(const Node & n);
};


Node::Node(Node & n) // this is not deep copy
{
data = n.data;
next = n.next;
}

bool Node::operator ==(const Node & n)
{
return (data == n.data && next == n.next);
}

Node & Node::operator= (const Node & n) // this is not deep copy
{
this->data = n.data;
this->next = n.next;
return *this;
}

bool Node::operator <(const Node & n)
{
return (data < n.data);
}

int ListLength(Node * p)
{
Node * temp = p;
int len=0;
while(temp->getNext()!=NULL)
{
len++;
temp = temp->getNext();
}
return len;
}



int main()
{
Node x,y,z;

int data;
cout<<"input the data of Node x:";
cin>>data;
x.setData(data);

cout<<"input the data of Node y:";
cin>>data;
y.setData(data);

cout<<"input the data of Node z:";
cin>>data;
z.setData(data);

x.setNext(&y);
y.setNext(&z);
z.setNext(NULL);

Node p = x;

Node *pp = &p;
while(pp!=NULL)
{
cout<<pp->getData()<<" ";
pp =pp->getNext();
}
cout<<endl;

return 0;
}[/CODE]