求助!!把c程序改成c++程序

[grellen]

有谁能够帮忙把下面的程序改成C++的!!!!谢谢!!
#include <stdio.h>
#include <stdlib.h>

#define ElemType int
#define HUNTHOU 10000

typedef struct LNode //链表节点
{
ElemType data;
struct LNode *next;
}ListNode, *LinkedList;
//==============================================
int InitList(LinkedList &list) //构造一个空的线形表list
{

list = (LinkedList)malloc(sizeof(ListNode));
if(!list)
{
exit(-1); //堆分配失败
}

list->data = -1;
list->next = NULL;

return 0;
}
//======================================================
int DestroyList(LinkedList &list) //销毁线性表list
{

ListNode * node=NULL;
if(list)
{
do
{
node = list->next;
free(list);
list = node;
}
while(list);
}

return 0;
}
//===================================================
int GetElem(LinkedList list, int index, ElemType &e)//获得list第index个节点，用e返回
{
ListNode *p=list->next;
int j =1;

while( p && j<index) //查找第index个节点
{
p=p->next;
++j;
}

if(!p || j>index) //index不合法
{
return -1;
}

e=p->data;
return 0;
}
//===================================================
int ListInsert(LinkedList &list, int index, ElemType e)//向list第index位置之前插入e
{
ListNode *p=list;
int j =0;

while( p && j<index-1) //查找第index-1个节点
{
p=p->next;
++j;
}

if(!p || j>index-1) //index不合法
{
return -1;
}

ListNode *n =(ListNode*) malloc( sizeof(ListNode) );
if(!n)
{
exit(-1);
}
n->data = e; //生成节点
n->next = p->next;

p->next = n;
return 0;
}
//====================================================
int ListTraverse(LinkedList list, int(*Visit)(ElemType e), int tag)//遍历list，对每个数据元素调用visit
{
LinkedList p =list->next;
if(tag==1) //顺序访问
{
while(p)
{
Visit(p->data);
p=p->next;
}
return 0;
}
else if(tag==0) //逆续访问
{
int i = 0;
while(p)
{
++i;
p=p->next;
}

while(i>0)
{
ElemType e;
GetElem(list,i--,e);
Visit(e);
}
return 0;
}
else
{
return -1;
}
}

//==========================================================
void Input(LinkedList &list) //输入大数，转换按标准形式存储
{
//printf("输入大的正整数……\n");
char c;
LinkedList l;
InitList(l);
while( (c=getchar()) != '\n')
{
if(c>='0' && c<= '9')
{
ListInsert(l,1,c-'0');//c-'0' 逆续存入临时链表
}
}

LinkedList p=l->next;
int last=1;
while(p) //转换存储方式
{
int a[4]={0};
for(int i=0; i<4; i++)
{
a[i] = p->data;
p=p->next;
if(!p) break;
}
int temp = a[0] + a[1]*10 + a[2]*100 + a[3]*1000;
ListInsert(list,last++,temp);//总是将temp插入list末尾
}

DestroyList(l);
}
//=============================================================
int AddHuge(LinkedList list1,LinkedList list2,LinkedList &result)//result=list1+list2 大数相加
{
ListNode *p,*q,*r;
LinkedList t1=NULL,t2=NULL;

if(list1 == result)//若list1与result相同
{
InitList(t1);
int i=0;
p=list1->next;
while(p)
{
ListInsert(t1,++i,p->data);
p=p->next;
}
p=t1->next;
}
else
{
p=list1->next;
}

if(list2 == result)//若list2与result相同
{
InitList(t2);
int i=0;
q=list2->next;
while(q)
{
ListInsert(t2,++i,p->data);
q=q->next;
}
q=t2->next;
}
else
{
q=list2->next;
}

if(result->next)//清空result
{
DestroyList(result);
InitList(result);
}

int total=0,carry=0,number=0;
int i = 0;

while(p && q)
{
total = p->data + q->data + carry;
number = total % HUNTHOU;
carry = total / HUNTHOU;
ListInsert(result,++i,number);//插入到末尾
p=p->next;
q=q->next;
}

r=(p)?p:q;
while(r)
{
total = r->data + carry;
number = total % HUNTHOU;
carry = total / HUNTHOU;
ListInsert(result,++i,number);//插入到末尾
r=r->next;
}

if(carry>0)
{
ListInsert(result,++i,carry);//插入到末尾
}

DestroyList(t1);
DestroyList(t2);
return 0;
}
//============================================================
int HugeMulInt(LinkedList list, int num, LinkedList &result) //大数乘小正整数
{
ListNode *p=NULL;
LinkedList t1 = NULL;

int number=0,carry=0,total=0;
int i=0;

if(list == result)
{
InitList(t1);
int j=0;
p=list->next;
while(p)
{
ListInsert(t1,++j,p->data);
p=p->next;
}
p=t1->next;
}
else
{
p=list->next;
}

if(result->next)
{
DestroyList(result);
InitList(result);

[HelloDan]

#include<iostream>
#include<cstdlib>
//将头文件换成上面的，因为C++是兼容C的。

[grellen]

我是想把这个程序改成用类实现,请各位帮帮忙,谢谢!!!!!!

[DonaldKnuth]

无非是一个链式线性表，定义一个节点类，一个链表类拥有一个指向链表头节点的指针，再封装对链表的各种操作，包括插入,删除,查找，异常处理等等，如下
#ifndef _CHAINLIST_H_
#define _CHAINLIST_H_

#include <iostream>
#include <exception>
using namespace std;


template<typename T> //必须首先声明，注意声明格式
class Chain;
template<typename T>
class ChainIterator;

template <typename T>
class ChainNode
{
friend ChainIterator<T>;
friend Chain<T>; //使用前Chain必须先声明
private:
T data;
ChainNode<T> *link;
};


template<typename T>
class Chain
{
friend ChainIterator<T>;
public:
//---------------------------------------------------------------
//常规：
Chain(){first = 0;}
~Chain();
bool IsEmpty() const {return first == 0;}
int Length() const;
bool Find(int k, T& x) const; // 寻找链表中的第k个元素，并将其传送至x
int Search(const T& x) const; //寻找x，如果发现x，则返回x的地址
Chain<T>& Delete(int k, T& x); //把第k个元素取至x，然后从链表中删除第k个元素
Chain<T>& Insert(int k, const T& x);
// 在第k个元素之后插入x
//如果不存在第k个元素，则引发异常OutOfBounds
// 如果没有足够的空间，则传递NoMem异常
void Output(ostream& out) const;

//-----------------------------------------------------------------
//扩展：
void Erase();
void Zero(){ first = 0;}
Chain<T> & Append(const T& x);
//自定义的异常处理类
public:
class NoMem:public std::exception
{
public:
virtual const char* what() const throw()
{
return "there is no memory!";
}
};

class OutOfBounds:public std::exception
{
public:
virtual const char* what() const throw()
{
return "out of bound!";
}
};
private:
ChainNode<T> *first; // 指向第一个节点的指针
ChainNode<T> *last; //指向最后一个指针
};

//-------------------------------------------------------------
//链表遍历器类
template<class T>
class ChainIterator
{
public:
T* Initialize(const Chain<T>& c)
{
//访问Chain中的私有成员必须先声明为其友元
location = c.first;
if(location)
return &location->data;
return 0;
}
T* Next()
{
if(!location) return 0;
location=location->link;
if(location)//访问ChainNode<T>的私有成员同样必先声明为期友元
return &location->data;
return 0;
}
private:
ChainNode<T> *location;
};


//---------------------------------------------------------

template<typename T>
Chain<T>::~Chain( )
{ // 链表的析构函数，用于删除链表中
ChainNode<T> *next; // 下一个节
while(first)
{
next = first->link;
delete first;
first = next;
}
}


//------------------------------------------------------------
template<typename T>
int Chain<T>::Length() const
{ // 返回链表中的元素总数
ChainNode<T> *current=first;
int len = 0;
while(current)
{
len++ ;
current = current->link;
}
return len;
}


//----------------------------------------------------------
template<typename T>
bool Chain<T>::Find(int k, T& x) const
{ // 寻找链表中的第k个元素，并将其传送至x
//如果不存在第k个元素，则返回false，否则返回true
if(k<1) return false;
ChainNode<T> *current=first;
int index = 1; // current的索引
while(index<k&¤t)
{
current=current->link;
index++;
}

if (current){x = current->data; return true;}
return false; // 不存在第k个元素
}

//------------------------------------------------------------
template<typename T>
int Chain<T>::Search(const T& x) const
{ // 寻找x，如果发现x，则返回x的地址
//如果x不在链表中，则返回0
ChainNode<T> *current=first;
int index=1; // current的索引
while(current&¤t->data!=x)
{
current=current->link;
index++;
}
if(current)
return index;
return 0;
}

//------------------------------------------------------------

template<typename T>
void Chain<T>::Output(ostream& out) const
{ // 将链表元素送至输出流
ChainNode<T> *current;
for(current=first;current;current=current->link)
out<<current->data<<" ";
}

template <typename T>
ostream& operator<<(ostream& out, const Chain<T> & x)
{
x.Output(out);
return out;
}

//------------------------------------------------------------
template<typename T>
Chain<T>& Chain<T>::Delete(int k, T& x)
{ // 把第k个元素取至x，然后从链表中删除第k个元素
//如果不存在第k个元素，则引发异常OutOfBounds
if(k<1||!first)
throw OutOfBounds(); // 不存在第k个元素
// p最终将指向第k个节点
ChainNode<T> *p=first;
// 将p移动至第k个元素，并从链表中删除该元素
if(k==1) // p已经指向第k个元素
first=first->link; // 删除之
else
{ // 用q指向第k - 1个元素
ChainNode<T> *q=first;
for(int index=1;index<k-1&&q;index++)
q=q->link;
if(!q||!q->link) //q指向的是k-1个元素
throw OutOfBounds(); //不存在第k个元素
p=q->link; // 存在第k个元素
if(p==last)
last=q; //使last始终指向最后
q->link=p->link;// 从链表中删除该元素
//保存第k个元素并释放节点p
}
x=p->data;

delete p;
return *this;
}

//-----------------------------------------------------------------
template<typename T>
Chain<T>& Chain<T>::Insert(int k, const T& x)
{ // 在第k个元素之后插入x
//如果不存在第k个元素，则引发异常OutOfBounds
// 如果没有足够的空间，则传递NoMem异常
if(k<0) throw OutOfBounds();
//p最终将指向第k个节点
ChainNode<T> *p=first;
//将p移动至第k个元素
for(int index=1;index<k&&p;index++)
p=p->link;
if(k>0&&!p) throw OutOfBounds(); //不存在第k个元素
// 插入
ChainNode<T> *y=new ChainNode<T>;
y->data=x;
if(k)
{// 在p之后插入
y->link=p->link;
p->link = y;
}
else
{// 作为第一个元素插入
y->link = first;
first = y;
}
if(!y->link)
last=y; //如果插入的是最后一个元素使last指向插入的元素
return *this;
}

//-----------------------------------------------------------
template<class T>
void Chain<T>::Erase()
{ //删除链表中的所有节点
ChainNode<T> *next;
while(first)
{
next=first->link;
delete first;
first=next;
}
}

//-----------------------------------------------------------
template<class T>
Chain<T> & Chain<T>::Append(const T& x)
{ //在链表尾部添加x
ChainNode<T> *y;
y=new ChainNode<T>;
y->data=x;
y->link=0;
if(first)
{//链表非空
last->link = y;
last = y;
}
else // 链表为空
first=last=y;
return *this;
}
#endif

[grellen]

什么啊,程序的内容都不一样!!


最好改成有重载输入,输出操作符的,谢谢.

[grellen]

自己顶

[goodmrning]

我改发好了,你加我!!!!!