编程实现计算2个高精度正整数的和。以单链表作为高精度整数的存储结构，头结点后的第一个结点存放个位数（最低位），第二个结点存放士位数，第三个结点存放百位数，以此类推。利用栈实现从高位数到低位数 （逆向）的数据输入和输出。

以下是使用C++语言实现的代码：

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

struct Node {
    int val;
    Node* next;
    Node(int v) : val(v), next(nullptr) {}
};

class BigInt {
private:
    Node* head;
public:
    BigInt() : head(nullptr) {}
    ~BigInt() {
        Node* p = head;
        while (p != nullptr) {
            Node* temp = p->next;
            delete p;
            p = temp;
        }
    }

    void push_front(int val) {
        Node* newNode = new Node(val);
        newNode->next = head;
        head = newNode;
    }

    void input() {
        string s;
        cin >> s;
        for (int i = 0; i < s.size(); i++) {
            push_front(s[i] - '0');
        }
    }

    void output() {
        Node* p = head;
        while (p != nullptr) {
            cout << p->val;
            p = p->next;
        }
        cout << endl;
    }

    BigInt operator+(const BigInt& other) const {
        BigInt ans;
        Node *p = head, *q = other.head;
        int carry = 0;
        while (p != nullptr || q != nullptr) {
            int x = (p == nullptr) ? 0 : p->val;
            int y = (q == nullptr) ? 0 : q->val;
            int sum = x + y + carry;
            carry = sum / 10;
            ans.push_front(sum % 10);
            if (p != nullptr) p = p->next;
            if (q != nullptr) q = q->next;
        }
        if (carry > 0) {
            ans.push_front(carry);
        }
        return ans;
    }
};

int main() {
    BigInt a, b;
    stack<int> s;
    cout << "Input two big integers:" << endl;
    a.input();
    b.input();
    BigInt c = a + b;
    cout << "The sum is:";
    c.output();
    return 0;
}

该程序中定义了一个 `BigInt` 类，使用单链表作为高精度整数的存储结构。其中，`push_front` 函数用于在链表的头部插入新的节点，`input` 函数利用栈实现了逆向输入数据，`output` 函数按正向输出数据。`operator+` 函数重载了加法运算符，实现了两个高精度整数的相加。

在主函数中，首先创建了两个 `BigInt` 类型的变量 `a` 和 `b`，然后调用 `input` 函数从标准输入中读入这两个整数。接着，调用 `operator+` 函数计算它们的和，并将结果存储在变量 `c` 中。最后，调用 `output` 函数输出结果。