c++编写完整程序，要求用十字链表实现下列两个稀疏矩阵的加，即：A=A+B。 A=12 0 0 -1 0 3 0 0 0 0 2 0 0 0 10 0 B=0 7 0 0 0 3 0 0 0 0 -2 0 9 0 0 8

在C++中，我们可以使用十字链表（也称对角链表或双向邻接列表）来表示稀疏矩阵。这个数据结构允许我们高效地存储非零元素，并且对于加法操作特别合适，因为只需要遍历一次链表即可。下面是一个简单的示例，展示了如何创建这样的链表并实现稀疏矩阵的加法：

#include <iostream>
#include <unordered_map>

// 定义节点结构体，包含值和指向其他节点的指针
struct Node {
    int value;
    Node* up, *down, *left, *right;
};

// 十字链表的类
class DiagonalLinkedList {
private:
    std::unordered_map<int, Node*> map;

public:
    // 添加新节点到链表
    void add(int i, int j, int value) {
        if (map.find(i) == map.end()) {
            map[i] = new Node{value};
            map[i]->up = nullptr;
            map[i]->down = nullptr;
            map[j] = map[i];
            map[j]->left = nullptr;
            map[j]->right = nullptr;
        } else {
            Node* node = map[i];
            if (node->j != j) {  // 如果不是当前列，则需要添加新的节点
                Node* newNode = new Node{value};
                newNode->up = node->up;
                newNode->down = node;
                newNode->left = node;
                newNode->right = node->right;
                map[j] = newNode;
            }
        }
    }

    // 稀疏矩阵相加
    void addMatrices(DiagonalLinkedList& other) {
        for (const auto& entry : map) {
            Node* node = entry.second;
            while (node) {
                if (other.map.find(node->j) != other.map.end()) {
                    node->value += other.map[node->j]->value;
                }
                node = node->down;
            }
        }
    }

    // 打印矩阵
    void print() const {
        for (const auto& pair : map) {
            Node* node = pair.second;
            while (node) {
                std::cout << node->value << " ";
                node = node->right;
            }
            std::cout << "\n";
        }
    }
};

int main() {
    DiagonalLinkedList a, b;
    a.add(0, 0, 12);
    a.add(0, 2, -1);
    a.add(2, 2, 2);
    a.add(3, 3, 10);

    b.add(0, 1, 7);
    b.add(1, 1, 3);
    b.add(1, 3, -2);
    b.add(2, 0, 9);
    b.add(2, 3, 8); // 注意索引对应关系

    a.addMatrices(b);
    a.print();
    
    return 0;
}

在这个例子中，`main()`函数首先初始化了两个稀疏矩阵A和B，然后通过`addMatrices`方法将它们相加。最后，`print`函数用于打印结果。