时间戳

首页 > 解决方案 > 发生异常：跟踪/断点陷阱 - 在 VSCode 中调试 C++ 程序（使用动态内存分配）

c++ - 发生异常：跟踪/断点陷阱 - 在 VSCode 中调试 C++ 程序（使用动态内存分配）

问题描述

我在此代码中使用动态内存分配来删除节点。遇到delete someVarVSCode 调试器时出现错误。

Exception has occurred
Trace/breakpoint trap

我不明白Trace/breakpoint trap是什么意思。你能解释一下吗？另外，请帮助我检测我的代码有什么问题？（顺便说一句，这是我为 leetcode 设置的解决方案，请忽略 main 中列表的冗长设置）

#include <iostream>
#include <map>


using std::cin;
using std::cout;
using std::endl;
using std::map;


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */


class ListNode {
public:
    ListNode *next;
    int val;
    ListNode(int arg_val = 0, ListNode* arg_next = nullptr) {
        val = arg_val;
        next = arg_next;
    }
};


class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* arg_head, int arg_n) {
        ListNode* head = arg_head;
        ListNode* traverser = arg_head;
        ListNode* nexter = arg_head->next;
        ListNode* previous = traverser;
        int index = 0;
        bool zero = false;
        map<int, ListNode*> store;
        signed int justcals[] = {arg_n - 0,
                                 arg_n - 5,
                                 arg_n - 10,
                                 arg_n - 15,
                                 arg_n - 20,
                                 arg_n - 25,
                                 arg_n - 30};

        if (arg_n == 1) {
            delete traverser;
            traverser = nullptr;
            return nexter;
        }

        while (traverser->next != nullptr) {
            if (index % 5 == 0) store.insert({index, traverser});
            traverser = traverser->next;
            index = index + 1;
        }
        int min = 99999;
        for (index = 0; index < 7; ++index) {
            if (justcals[index] >= 0 && justcals[index] < min) {
                if (justcals[index] == 0) {
                    zero = true;
                    min = justcals[index - 1] + (5 * (index - 1));
                } else {
                    if (index == 0) min = 0;
                    else min = justcals[index] + (5 * index);
                }
            }
        }
        traverser = store.at(min);
        index = min;
        if (zero) {
            traverser = head;
            index = 0;
        }
        while (index != arg_n - 1) {
            traverser = traverser->next;
            index = index + 1;
        }
        traverser = traverser->next;
        nexter = traverser->next;
        delete traverser;
        previous->next = nexter;
        return head;
    }
};


int main() {
    Solution solver;
    ListNode *lsptr;
    ListNode node1(1);
    ListNode node2(2);
    ListNode node3(3);
    ListNode node4(4);
    ListNode node5(5);
    ListNode node6(6);
    ListNode node7(7);
    lsptr = &node2; node1.next = lsptr;
    lsptr = &node3; node2.next = lsptr;
    lsptr = &node4; node3.next = lsptr;
    lsptr = &node5; node4.next = lsptr;
    lsptr = &node6; node5.next = lsptr;
    lsptr = &node7; node6.next = lsptr;
    lsptr = &node1;
    cout << &*(solver.removeNthFromEnd(lsptr, 3)) << endl;
    return 0;
}

标签： c++visual-studio-code

解决方案

delete只能与使用 . 创建的对象一起使用new。

您在堆栈上创建对象并设置lsptr为指向它们。请注意，列表节点不是由new. 然后删除lsptr，这是无效的，因为它们不是由new. 这会导致异常。程序不处理异常，因此它通知操作系统程序已失败。这称为陷入操作系统。然后操作系统通过以下任一方式处理故障：停止程序并跳转到调试器（如果已设置），也就是断点陷阱，或终止您的程序。

要修复程序，请删除删除。您不需要删除堆栈分配，只需删除堆分配的对象 ( new)。

推荐阅读