关于链表的应用。解决方法

关于链表的应用。。。
《数据结构》课程设计
课题
链表的应用
设计平台
DOS或   Windows   98
Turbo   C   2.0或Borland   C++   3.0或PASCAL语言
设计要求
用链表实现：输入两个任意长的正整数，求它们的和并显示。
设计思路
1、输入到字符串中，从低到高每N个数字字符转换成整数并存到链表的一个节点，建立两个链表
2、从低到高将A链表与B链表的对应节点相加，并存到C链表的对应节点，和若大于N位数则要进位
3、输出C链表的各节点


请帮帮忙。。。
学习学习~

[解决办法]
给你贴上吧

#ifndef _STLP_INTERNAL_LIST_H
#define _STLP_INTERNAL_LIST_H

# ifndef _STLP_INTERNAL_ALGOBASE_H
# include <stl/_algobase.h>
# endif

# ifndef _STLP_INTERNAL_ALLOC_H
# include <stl/_alloc.h>
# endif

# ifndef _STLP_INTERNAL_ITERATOR_H
# include <stl/_iterator.h>
# endif

# ifndef _STLP_INTERNAL_CONSTRUCT_H
# include <stl/_construct.h>
# endif

# ifndef _STLP_INTERNAL_FUNCTION_BASE_H
# include <stl/_function_base.h>
# endif

_STLP_BEGIN_NAMESPACE

# undef list
# define list __WORKAROUND_DBG_RENAME(list)

struct _List_node_base {
_List_node_base* _M_next;
_List_node_base* _M_prev;
};

template <class _Dummy>
class _List_global {
public:
typedef _List_node_base _Node;
static void _STLP_CALL _Transfer(_List_node_base* __position,
_List_node_base* __first, _List_node_base* __last);
};

# if defined (_STLP_USE_TEMPLATE_EXPORT)
_STLP_EXPORT_TEMPLATE_CLASS _List_global <bool> ;
# endif
typedef _List_global <bool> _List_global_inst;

template <class _Tp>
struct _List_node : public _List_node_base {
_Tp _M_data;
__TRIVIAL_STUFF(_List_node)
};

struct _List_iterator_base {
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef bidirectional_iterator_tag iterator_category;

_List_node_base* _M_node;

_List_iterator_base(_List_node_base* __x) : _M_node(__x) {}
_List_iterator_base() {}

void _M_incr() { _M_node = _M_node-> _M_next; }
void _M_decr() { _M_node = _M_node-> _M_prev; }
bool operator==(const _List_iterator_base& __y ) const {
return _M_node == __y._M_node;
}
bool operator!=(const _List_iterator_base& __y ) const {
return _M_node != __y._M_node;
}
};


template <class _Tp, class _Traits>
struct _List_iterator : public _List_iterator_base {
typedef _Tp value_type;
typedef typename _Traits::pointer pointer;
typedef typename _Traits::reference reference;

typedef _List_iterator <_Tp, _Nonconst_traits <_Tp> > iterator;
typedef _List_iterator <_Tp, _Const_traits <_Tp> > const_iterator;
typedef _List_iterator <_Tp, _Traits> _Self;

typedef bidirectional_iterator_tag iterator_category;
typedef _List_node <_Tp> _Node;
typedef size_t size_type;
typedef ptrdiff_t difference_type;

_List_iterator(_Node* __x) : _List_iterator_base(__x) {}
_List_iterator() {}
_List_iterator(const iterator& __x) : _List_iterator_base(__x._M_node) {}

reference operator*() const { return ((_Node*)_M_node)-> _M_data; }

_STLP_DEFINE_ARROW_OPERATOR

_Self& operator++() {
this-> _M_incr();
return *this;
}
_Self operator++(int) {
_Self __tmp = *this;
this-> _M_incr();
return __tmp;

}
_Self& operator--() {
this-> _M_decr();
return *this;
}
_Self operator--(int) {
_Self __tmp = *this;
this-> _M_decr();
return __tmp;
}
};


#ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
template <class _Tp, class _Traits>
inline _Tp* value_type(const _List_iterator <_Tp, _Traits> &) { return 0; }
inline bidirectional_iterator_tag iterator_category(const _List_iterator_base&) { return bidirectional_iterator_tag();}
inline ptrdiff_t* distance_type(const _List_iterator_base&) { return 0; }
#endif


// Base class that encapsulates details of allocators and helps
// to simplify EH

template <class _Tp, class _Alloc>
class _List_base
{
protected:
_STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
typedef _List_node <_Tp> _Node;
typedef typename _Alloc_traits <_Node, _Alloc> ::allocator_type
_Node_allocator_type;
public:
typedef typename _Alloc_traits <_Tp, _Alloc> ::allocator_type
allocator_type;

allocator_type get_allocator() const {
return _STLP_CONVERT_ALLOCATOR((const _Node_allocator_type&)_M_node, _Tp);
}

_List_base(const allocator_type& __a) : _M_node(_STLP_CONVERT_ALLOCATOR(__a, _Node), (_Node*)0) {
_Node* __n = _M_node.allocate(1);
__n-> _M_next = __n;
__n-> _M_prev = __n;
_M_node._M_data = __n;
}
~_List_base() {
clear();
_M_node.deallocate(_M_node._M_data, 1);
}

void clear();

public:
_STLP_alloc_proxy <_Node*, _Node, _Node_allocator_type> _M_node;
};

template <class _Tp, _STLP_DEFAULT_ALLOCATOR_SELECT(_Tp) >
class list;

// helper functions to reduce code duplication
template <class _Tp, class _Alloc, class _Predicate>
void _S_remove_if(list <_Tp, _Alloc> & __that, _Predicate __pred);

template <class _Tp, class _Alloc, class _BinaryPredicate>
void _S_unique(list <_Tp, _Alloc> & __that, _BinaryPredicate __binary_pred);

template <class _Tp, class _Alloc, class _StrictWeakOrdering>
void _S_merge(list <_Tp, _Alloc> & __that, list <_Tp, _Alloc> & __x,
_StrictWeakOrdering __comp);

template <class _Tp, class _Alloc, class _StrictWeakOrdering>
void _S_sort(list <_Tp, _Alloc> & __that, _StrictWeakOrdering __comp);


[解决办法]

int nA = 1234;
int nB = 366;

bool IsMore = false;

AList 1 -- 2 -- 3 -- 4
|
移动 <-pForA

BList 3 -- 6 -- 6
|
移动 <-pForB

//按短链表长度来控制移动次数
用bool控制进位
计算结果保存到C链表
多出部分计算进位后 直接复制到C