简单的程序题目，帮忙看看哪里的问题，一定给分！！！

[pcfarmer]

#include<iostream.h>
#include<stdio.h>
#define LIST_SIZE 100
#define TRUE 1
#define FALSE 0
class link
{
public:
int data;
link* next;
link* prev;
// static link* freelist;
// link( );
};

class list
{
public:
list(); //构造函数，用于类对象的初始化
~list(); //析构函数
void clear(); //清空类对象
int length(); //返回实际长度
void insert_front(int num); //插入新的表头，存储数据为num
void insert_end(int num); //插入新的表尾，存储数据为num
list(list& arr); //拷贝构造函数，用于类对象的复制
bool isEmpty(); //若为空返回TRUE

link* head;
link* tail;
link* curr;
};

//下面为重载加法、减法、乘法、取模运算符的函数声明部分：
list operator + (list& left,list& right);
list operator - (list& left,list& right);
list operator * (list& left,list& right);
list operator % (list& left,list& right);

list::list() //构造函数，类对象的初始化，此时对象为空
{ head=new link;
head->next=head;
head->prev=head;
tail=head;curr=head;

}

list::~list () //析构函数，依次delete所有结点
{
while(head!=NULL)
{
curr=head;
head=head->next ;
delete curr;
}
}

list::list(list& arr)
{
tail=head=curr=new link; //先初始化
head->next=head;
head->prev=head;

if(!arr.isEmpty()) //若非空则进行复制
{
link* q=arr.head;
while(q->next!=arr.head)
{
q=q->next;
insert_end(q->data); //依次插入到表尾
}
}
}
void list::insert_end(int num) //在末尾插入新的结点

{
if(head->next==head) //且赋值为num
{
tail=new link;
head->next=tail;
tail->prev=head;
head->prev=tail;
tail->next=head;
tail->data=num;
}
else
{
tail->next=new link;
tail->next->prev=tail;
tail=tail->next;
tail->next=head;
head->prev=tail;
tail->data=num;
}
}
void list::insert_front(int num) //在前面（最高位）插入结点
{ //且数值为num
if(head->next==head)
{
tail=new link;
tail->data=num;
head->next=tail;
head->prev=tail;
tail->next=head;
tail->prev=head;
}
else
{
link* p=new link;
p->next=head->next;
p->next->prev=p;
head->next=p;
p->prev=head;
p->data=num;
}
}
void list::clear ()
{
while(head->next !=head)
{
curr=head->next;
head->next=curr->next;
delete curr;
}
curr=tail=head;
head->next=head;
head->prev=head;
}

/*length函数用来求该链表实际的位数（去除高位连续为0的位数）。
先求总体长度，然后从高位开始判断，若最高位是0，cnt减1，继续往低位看，仍为0则cn
t继续
减1，只要碰到非0数字即停止。此时cnt为链表中有意义的结点的长度。*/
int list::length()
{
int cnt=0;
for(link* temp=head->next;temp!=head;temp=temp->next )
cnt++;
link* p=head->next;
while(p!=head)
{
if(p->data!=0) break;
cnt--;
p=p->next;
}
return cnt;
}
bool list::isEmpty ()
{
return head->next==head;
}

//static list a;
/*下为重载加法运算符 + ：
声明一list类对象a，用来保存left和right的和；进位carry。
从表尾tail开始（即最低位），将对应的data数值相加，存放到a相应的位置，
即把相加之和插入到a的表头，注意进位carry，若和大于9，carry=1，带到下
一次循环中，若和不大于9，carry一定要恢复到0。
若left和right长度不等，第一个循环体结束后，继续将剩余部分插入到a表头，
注意仍要考虑进位。
若插入操作结束后carry=1，则要在高位补1，即在a表头插入一数值为1的新结点。*/



list operator + (list& left,list& right)
{
int carry=0; //进位
list a;
if((a.isEmpty())==FALSE)
a.clear(); //如果a不为空，则清空
link* leftail=left.tail;
link* rightail=right.tail;
link* til=new link;
while(leftail->prev!=left.tail&&rightail->prev!=right.tail)
{
til->data=leftail->data + rightail->data+carry;
if(til->data>9)
{
til->data-=10;
carry=1;
}
else carry=0;
a.insert_front(til->data);
leftail=leftail->prev;
rightail=rightail->prev;
}
while(leftail->prev!=left.tail)
{
til->data=leftail->data+carry;
if(til->data>9)
{
til->data-=10;
carry=1;
}
else carry=0;
a.insert_front(til->data);
leftail=leftail->prev;
}
while(rightail->prev!=right.tail)
{
til->data=rightail->data+carry;
if(til->data>9)
{
til->data-=10;
carry=1;
}
else carry=0;
a.insert_front(til->data);
rightail=rightail->prev;
}
if(carry!=0) //增加位数，最高位补1
{
a.insert_front(1);
}
return a;
}

/*下为重载减法运算符 - ：
具体思路同上述重载减法时类似，只是将原本相加的操作改成相减，
carry保存退位：若相减结果小于0，carry=-1，带到下一次循环中；
若不是，则恢复为0。*/
/*list operator -(list& left,list& right)
{
int carry=0; //借位
list a;
if((a.isEmpty())==FALSE)
a.clear(); //如果a不为空，则清空
link* leftail=left.tail;
link* rightail=right.tail;
link* til=new link;
while(rightail->prev!=right.tail)
{
til->data=leftail->data - rightail->data+carry;
if(til->data<0)
{
til->data+=10;
carry=-1;
}
else carry=0;
a.insert_front(til->data);
rightail=rightail->prev;
leftail=leftail->prev;
}
while(leftail->prev!=left.tail)
{
til->data=leftail->data+carry;
if(til->data<0)
{
til->data+=10;
carry=-1;
}
else carry=0;
a.insert_front(til->data);
leftail=leftail->prev;
}
return a;
}

/*该函数是用来比较left和right两个链表的存储数值的大小。
若left>right，则返回1；若left<right，则返回-1；若相等则返回0。*/

/*int compare(list& left,list& right)
{
int lefth=left.length (); //length函数为求链表中实际有效位数（去除高位中
的0个数）
int righth=right.length ();
if(lefth>righth)
return 1;
if(lefth<righth)
return -1;
else
{
link* k1=left.head->next;
link* k2=right.head->next;
while(k1!=left.head)
{
if((k1->data)>(k2->data))
return 1;
if((k1->data)<(k2->data))
return -1;
else
{
k1=k1->next;
k2=k2->next;
}
}
return 0;
}
}

/*下为重载乘法运算符 * ：
自定义分别等同于0和1的list类对象zero和unit；
声明一类对象multi保存乘积，list类mul标记循环次数。
初始mul=zero，每循环一次，mul增unit，multi增left，直到mul不小于right
为止，循环次数为right。
此时multi为重载意义下left与right的乘积。*/
/*list operator * (list& left,list& right)
{
list zero;
zero.insert_end(0);

list unit;
unit.insert_end(1);

static list multi=left;
for(list mul=zero;compare(mul,right)<0;mul=mul+unit)
multi=multi+left;
return multi;
}

/*下为重载取模运算符 % ：
声明一list类对象b，用来保存余数;
初始化b=left，若b比right大，就减去right（用到了重载减法的操作），
直到b比right小为止。
此时b即为余数。*/
/*list operator % (list& left,list& right)
{
static list b=left; //初始化b=left
while(compare(b,right)>=0) //若b比right大，就减去right
b=b-right;
return b;
}

/*hlj函数为求no1和no2的最小公倍数。
找出两者中较大者，赋给no（用来保存公倍数的list类），若no不能被另外
一个整除，就加较大者，直到no可以被它整除为止。
此时no即为要求的最小公倍数。*/
/*list hlj(list& No1,list& No2)
{
list zero;
zero.insert_end(0);

static list No;
if(compare(No1,No2)>0)
{
No=No1;
while(compare(No%No2,zero)>0)
No=No+No1;
}
else
{
No=No2;
while(compare(No%No1,zero)>0)
No=No+No2;
}
return No;
}

/*xlz函数求一list类对象a，它能被no3、no2整除，而被no1整除余数为unit
（等同于1的list类对象，下面以1代之）。
先找出no2、no3的最小公倍数no，将它复制给a；
若a%no1不为1，继续加no，直到等于1为止。
此时a即为要求的值。*/
/*list xlz(list& No1,list& No2,list& No3)
{
list a;
list unit;
unit.insert_end(1);

static list No=hlj(No2,No3);
if((a.isEmpty())==FALSE)
a.clear(); //如果a不为空，则清空
a=No;
while(compare(a%No1,unit)!=0)
a=a+No;
return a;
}
/*print函数为打印list类对象为整数形式的操作。
从表头（即高位）开始，依次打印其中存储的数据，到表尾结束。*/
void print(list& result)
{
cout<<"the result is:";
for(link* q=result.head->next;q!=result.head;q=q->next)
cout<<q->data;
cout<<endl;
}

void main()
{
list add;
//print(add);
///zero.insert_end(0);
///unit.insert_end(1);
/* char c;
cout<<" d1/d2/d3/r1/r2/r3:"<<endl;

for(int i=0;i<6;i++)
{
link* q=new link;
cin>>c;
while(c!='/')
{
q->data=c-'0';
list[i].insert_end(q->data);
cin>>c;
}
} //将d1等存储到list[]数组操作完毕！

list_A=xlz(list[0],list[1],list[2]);
list_B=xlz(list[1],list[0],list[2]);
list_C=xlz(list[2],list[0],list[1]);
list_X=list_A*list[3]+list_B*list[4]+list_C*list[5];
list_M=list[0]*list[1]*list[2];
list_X=list_X%list_M;
print(list_X);
cout<<"终于成功了！"<<endl;*/
//zero+unit;
///add=zero+unit;
// print(add);
}

//经反复debug，发觉直到a返回给add时突变成未知数值。

[MountLion]

a 是局部变量，函数结束时自动释放，调用了析构函数，当然数据不复存在了。
换个思路吧。

[MountLion]

a 是局部变量，函数结束时自动释放，调用了析构函数，当然数据不复存在了。
换个思路吧。