设计一个C++链表类，它能将数字存入链表中，并且可以重载-以实现两个百位数相减

好的，我可以帮你设计一个C++链表类，并重载-运算符，实现两个百位数相减。

首先，我们需要定义一个链表节点类，它包含一个整型数据和一个指向下一个节点的指针。代码如下：

class ListNode {
public:
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

然后，我们定义一个链表类，它包含一个指向链表头部的指针和链表的长度。代码如下：

class LinkedList {
public:
    ListNode* head;
    int size;
    LinkedList() : head(nullptr), size(0) {}
    ~LinkedList() {
        while (head) {
            ListNode* temp = head;
            head = head->next;
            delete temp;
        }
    }
    void insert(int x) {
        ListNode* node = new ListNode(x);
        node->next = head;
        head = node;
        size++;
    }
};

接下来，我们重载-运算符，实现两个百位数相减。我们先定义一个函数，用来计算两个链表的差值。代码如下：

LinkedList subtract(LinkedList& l1, LinkedList& l2) {
    LinkedList res;
    ListNode* p1 = l1.head;
    ListNode* p2 = l2.head;
    int borrow = 0;
    while (p1 || p2) {
        int val1 = p1 ? p1->val : 0;
        int val2 = p2 ? p2->val : 0;
        int diff = val1 - val2 - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        res.insert(diff);
        if (p1) p1 = p1->next;
        if (p2) p2 = p2->next;
    }
    while (res.head->val == 0 && res.head->next) {
        ListNode* temp = res.head;
        res.head = res.head->next;
        delete temp;
        res.size--;
    }
    return res;
}

最后，我们重载-运算符，代码如下：

LinkedList operator-(LinkedList& l1, LinkedList& l2) {
    LinkedList res;
    if (l1.size < l2.size) {
        res.insert(0);
        return res;
    }
    if (l1.size == l2.size) {
        ListNode* p1 = l1.head;
        ListNode* p2 = l2.head;
        bool flag = true;
        while (p1 && p2) {
            if (p1->val > p2->val) {
                flag = false;
                break;
            } else if (p1->val < p2->val) {
                flag = true;
                break;
            }
            p1 = p1->next;
            p2 = p2->next;
        }
        if (flag) {
            res.insert(0);
            return res;
        }
    }
    res = subtract(l1, l2);
    return res;
}

现在，我们就可以使用这个链表类，实现两个百位数的减法运算了。