C++的崩溃与Core Dump调试指南

#include <sys/resource.h>
#include <signal.h>

// 启用Core Dump
void enableCoreDump() {
    struct rlimit rlim;
    rlim.rlim_cur = RLIM_INFINITY;
    rlim.rlim_max = RLIM_INFINITY;

    if (setrlimit(RLIMIT_CORE, &rlim) != 0) {
        perror("setrlimit failed");
    }
}

// 信号处理函数
void signalHandler(int sig) {
    printf("Received signal %d, generating core dump\n", sig);
    signal(sig, SIG_DFL);  // 恢复默认处理
    raise(sig);            // 重新发送信号
}

int main() {
    enableCoreDump();

    // 注册信号处理函数
    signal(SIGSEGV, signalHandler);
    signal(SIGABRT, signalHandler);

    // ... 程序逻辑
}

#include <iostream>

int main() {
    int* ptr = nullptr;
    std::cout << "About to crash..." << std::endl;
    *ptr = 42;  // SIGSEGV - 段错误
    return 0;
}

#include <iostream>

int main() {
    int arr[10];

    // 写越界 - 可能不会立即崩溃，但会破坏内存
    for (int i = 0; i <= 100; ++i) {
        arr[i] = i;
    }

    // 读越界 - 可能访问到无效内存
    std::cout << arr[1000] << std::endl;  // 潜在的SIGSEGV
    return 0;
}

#include <iostream>

int main() {
    int* ptr = new int(42);
    delete ptr;

    // 使用已释放的内存
    std::cout << *ptr << std::endl;  // 未定义行为，可能导致崩溃

    return 0;
}

#include <iostream>

void recursiveFunction(int depth) {
    char buffer[1024];  // 消耗栈空间
    std::cout << "Depth: " << depth << std::endl;
    recursiveFunction(depth + 1);  // 无终止条件的递归
}

int main() {
    recursiveFunction(0);  // 最终导致SIGSEGV
    return 0;
}

#include <thread>
#include <vector>
#include <iostream>

class UnsafeCounter {
private:
    int count = 0;

public:
    void increment() {
        // 非线程安全的操作
        int temp = count;
        temp++;
        count = temp;
    }

    int getValue() const { return count; }
};

int main() {
    UnsafeCounter counter;
    std::vector<std::thread> threads;

    // 创建多个线程同时操作共享数据
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&counter]() {
            for (int j = 0; j < 10000; ++j) {
                counter.increment();
            }
        });
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final count: " << counter.getValue() << std::endl;
    return 0;
}

// crash_test.cpp
#include <iostream>
#include <vector>
#include <memory>

class TestClass {
public:
    int value;
    TestClass(int v) : value(v) {}
    void print() { std::cout << "Value: " << value << std::endl; }
};

void problematicFunction(std::vector<int>& vec) {
    // 故意访问无效索引
    std::cout << vec[1000] << std::endl;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::unique_ptr<TestClass> obj = std::make_unique<TestClass>(42);

    obj->print();
    problematicFunction(numbers);

    return 0;
}

#include <windows.h>
#include <dbghelp.h>

LONG WINAPI TopLevelExceptionHandler(PEXCEPTION_POINTERS pExceptionInfo) {
    HANDLE hFile = CreateFile(L"crash.dmp", GENERIC_WRITE, 0, NULL,
                             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

    if (hFile != INVALID_HANDLE_VALUE) {
        MINIDUMP_EXCEPTION_INFORMATION mdei;
        mdei.ThreadId = GetCurrentThreadId();
        mdei.ExceptionPointers = pExceptionInfo;
        mdei.ClientPointers = FALSE;

        MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
                         hFile, MiniDumpNormal, &mdei, NULL, NULL);
        CloseHandle(hFile);
    }

    return EXCEPTION_EXECUTE_HANDLER;
}

int main() {
    SetUnhandledExceptionFilter(TopLevelExceptionHandler);

    // 触发崩溃的代码
    int* p = nullptr;
    *p = 42;

    return 0;
}