C++货币分类循环链表程序报错3221225725及功能实现咨询

报错原因定位 #

返回值3221225725对应的十六进制为0xC00000FD，属于栈溢出错误，触发的常见原因如下：

• 循环链表初始化/插入节点时，未将尾节点的next指针指向头节点，导致遍历链表时进入死循环，栈空间耗尽
• 链表遍历采用递归实现，当链表长度较大时递归层级过深爆栈
• 在栈区分配了过大的节点数组/结构体，超过栈内存上限

修复与完整实现代码 #

严格遵循循环链表操作规范实现所有需求，代码如下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
using namespace std;
// 汇率常量定义
const double USD_TO_INR = 73.0;
const double EUR_TO_INR = 86.5;
// 货币类型枚举
enum CurrencyType { USD, INR, EUR };
// 循环链表节点结构
struct Node {
    double original_value; // 原货币面值
    double inr_value;      // 换算为INR的价值
    Node* next;
    Node(double val, double inr) : original_value(val), inr_value(inr), next(nullptr) {}
};
// 货币筐结构：每个筐对应一个循环链表+预统计指标
struct CurrencyBasket {
    CurrencyType type;
    Node* head;
    Node* tail;
    int count;          // 货币总数量
    double total_inr;   // 总INR等值金额
    CurrencyBasket(CurrencyType t) : type(t), head(nullptr), tail(nullptr), count(0), total_inr(0) {}
    // 向筐中添加货币，同步更新统计值
    void add(double original_val) {
        double inr_val;
        if(type == USD) inr_val = original_val * USD_TO_INR;
        else if(type == INR) inr_val = original_val;
        else inr_val = original_val * EUR_TO_INR;
        Node* new_node = new Node(original_val, inr_val);
        // 循环链表插入逻辑，确保首尾关联
        if(!head) {
            head = new_node;
            tail = new_node;
            new_node->next = head;
        } else {
            tail->next = new_node;
            new_node->next = head;
            tail = new_node;
        }
        count++;
        total_inr += inr_val;
    }
    // 从筐中扣除指定INR等值金额，返回是否扣除成功
    bool remove(double target_inr) {
        if(target_inr > total_inr || count == 0) return false;
        double removed_sum = 0.0;
        // 实现逻辑：按插入顺序移除直到达到目标扣除额，可按需调整为最优凑数逻辑
        while(removed_sum < target_inr && count > 0) {
            Node* temp = head;
            removed_sum += temp->inr_value;
            total_inr -= temp->inr_value;
            count--;
            if(count == 0) {
                head = nullptr;
                tail = nullptr;
            } else {
                head = head->next;
                tail->next = head;
            }
            delete temp;
        }
        return true;
    }
    // 获取均值
    double get_mean() {
        return count == 0 ? 0 : total_inr / count;
    }
    // 获取中位数
    double get_median() {
        if(count == 0) return 0;
        vector<double> val_list;
        Node* cur = head;
        // 迭代遍历：用计数控制循环次数，避免死循环
        for(int i=0; i<count; i++) {
            val_list.push_back(cur->inr_value);
            cur = cur->next;
        }
        sort(val_list.begin(), val_list.end());
        if(count % 2 == 1) {
            return val_list[count/2];
        } else {
            return (val_list[count/2 - 1] + val_list[count/2]) / 2;
        }
    }
    // 获取众数
    double get_mode() {
        if(count == 0) return 0;
        unordered_map<double, int> cnt_map;
        Node* cur = head;
        for(int i=0; i<count; i++) {
            cnt_map[cur->inr_value]++;
            cur = cur->next;
        }
        int max_cnt = 0;
        double mode_val = 0;
        for(auto& pair : cnt_map) {
            if(pair.second > max_cnt) {
                max_cnt = pair.second;
                mode_val = pair.first;
            }
        }
        return mode_val;
    }
};
// 质数判断辅助函数
bool is_prime(int n) {
    if(n <= 1) return false;
    for(int i=2; i*i <=n; i++) {
        if(n % i == 0) return false;
    }
    return true;
}
// 数字分类规则：交集优先归EUR，剩余偶数归USD、奇数归INR
CurrencyType classify_num(int num) {
    if(is_prime(num)) return EUR;
    return num % 2 == 0 ? USD : INR;
}
int main() {
    CurrencyBasket usd_basket(USD), inr_basket(INR), eur_basket(EUR);
    // 读取用户输入
    int n;
    cout << "请输入货币数量：";
    cin >> n;
    cout << "请输入所有货币面值（空格分隔）：";
    for(int i=0; i<n; i++) {
        int val;
        cin >> val;
        CurrencyType type = classify_num(val);
        if(type == USD) usd_basket.add(val);
        else if(type == INR) inr_basket.add(val);
        else eur_basket.add(val);
    }
    // 功能交互
    int op;
    while(true) {
        cout << "\n1.查询所有筐统计指标 2.从筐中扣除金额 3.退出\n请选择操作：";
        cin >> op;
        if(op == 3) break;
        if(op == 1) {
            cout << "=== USD筐 ===" << endl;
            cout << "总金额(INR)：" << usd_basket.total_inr << " 均值：" << usd_basket.get_mean() << " 中位数：" << usd_basket.get_median() << " 众数：" << usd_basket.get_mode() << endl;
            cout << "=== INR筐 ===" << endl;
            cout << "总金额(INR)：" << inr_basket.total_inr << " 均值：" << inr_basket.get_mean() << " 中位数：" << inr_basket.get_median() << " 众数：" << inr_basket.get_mode() << endl;
            cout << "=== EUR筐 ===" << endl;
            cout << "总金额(INR)：" << eur_basket.total_inr << " 均值：" << eur_basket.get_mean() << " 中位数：" << eur_basket.get_median() << " 众数：" << eur_basket.get_mode() << endl;
        } else if(op == 2) {
            int basket_type;
            double amount;
            cout << "请选择筐（1.USD 2.INR 3.EUR）：";
            cin >> basket_type;
            cout << "请输入要扣除的INR等值金额：";
            cin >> amount;
            bool res;
            if(basket_type == 1) res = usd_basket.remove(amount);
            else if(basket_type == 2) res = inr_basket.remove(amount);
            else res = eur_basket.remove(amount);
            cout << (res ? "扣除成功" : "扣除失败：金额不足或筐为空") << endl;
        }
    }
    return 0;
}

关键修复点说明 #

• 所有循环链表插入操作强制校验尾节点next指向头节点，避免野指针导致的死循环
• 所有链表遍历均采用迭代+计数控制，禁止递归实现，从根源避免栈溢出
• 所有节点内存均在堆区分配，不会占用栈空间
• 分类逻辑明确交集优先级，避免规则冲突导致分类错误

内容的提问来源于stack exchange，提问作者Yash Malhotra