C++栈溢出实战案例解析

void riskyFunction() {
    // 在栈上分配一个巨大的数组，危险！
    double hugeMatrix[1000][1000]; // 假设double是8字节， 1000*1000*8 ≈ 8MB
    // ... 使用 hugeMatrix
}
// 这个函数一旦被调用，很大概率会立即导致栈溢出崩溃。

// 一个看似无害，实则危险的递归函数
void infiniteRecursion(int count) {
    int localVar = count; // 每个栈帧都有这个变量
    // 忘记或写错了递归终止条件！
    infiniteRecursion(count + 1); // 这将无限调用下去
}

#include <iostream>
// 场景1：深度递归
void deepRecursion(int depth) {
    int localData[100]; // 每个递归层都在栈上分配100个int
    if (depth <= 0) return; // 终止条件
    // 一些模拟操作...
    deepRecursion(depth - 1); // 递归调用
}
// 场景2：巨型局部数组
void processBigData() {
    // 试图在栈上处理一个“大”数据块
    int massiveBuffer[1024 * 1024]; // 4MB (假设int为4字节)！
    for (int i = 0; i < 1024 * 1024; ++i) {
        massiveBuffer[i] = i;
    }
    std::cout << "Processing finished, first element: " << massiveBuffer[0] << std::endl;
}
int main() {
    // 调用深度递归
    deepRecursion(10000); // 深度10000， 每层约400字节， 总共约4MB， 很可能溢出
    // 调用大数组函数
    processBigData(); // 直接声明4MB栈数组，在默认栈大小下几乎必然溢出
    return 0;
}

// 解决方案1：消除递归中的大局部变量（如果可能）
void deepRecursionOptimized(int depth) {
    // 移除了大型局部数组，栈帧变得非常小
    if (depth <= 0) return;
    deepRecursionOptimized(depth - 1);
}

// 解决方案2：将递归改为迭代（手动栈模拟）
void deepRecursionToIteration(int maxDepth) {
    // 使用std::stack在堆上模拟调用栈
    std::stack<int> taskStack;
    taskStack.push(maxDepth);

    while (!taskStack.empty()) {
        int currentDepth = taskStack.top();
        taskStack.pop();

        if (currentDepth > 0) {
            // 处理当前层逻辑...
            std::cout << "Processing depth: " << currentDepth << std::endl;
            // 模拟递归调用，将子任务压栈
            taskStack.push(currentDepth - 1);
        }
    }
}

// 解决方案：使用std::vector在堆上分配
void processBigDataSafe() {
    // 使用std::vector，数据存储在堆上
    std::vector<int> massiveBuffer(1024 * 1024); // 分配在堆上，大小仅受系统内存限制
    for (int i = 0; i < massiveBuffer.size(); ++i) {
        massiveBuffer[i] = i;
    }
    std::cout << "Processing finished safely, first element: " << massiveBuffer[0] << std::endl;
    // vector离开作用域时，其析构函数会自动释放堆内存，无需手动delete
}

void oldSchoolHeap() {
    int* bigArray = new int[1024 * 1024]; // 在堆上分配
    // ... 使用 bigArray
    delete[] bigArray; // 必须手动释放！
    // 如果中间有return或抛出异常，会导致内存泄漏
}

#include <memory>
#include <vector>
void modernHeapManagement() {
    // 1. 使用 unique_ptr 管理数组
    auto uniqueArray = std::make_unique<int[]>(1024 * 1024);
    // 使用 uniqueArray.get() 获取原始指针
    for (int i = 0; i < 1024 * 1024; ++i) {
        uniqueArray[i] = i;
    }
    // 函数结束时，uniqueArray自动析构，释放内存。无需手动delete！
    // 2. 使用 vector (本质上也是堆内存，但接口更友好)
    std::vector<double> largeDataSet;
    largeDataSet.reserve(5000000); // 在堆上预留500万个double的空间
    for (int i = 0; i < 5000000; ++i) {
        largeDataSet.push_back(i * 0.1);
    }
    // vector离开作用域，自动清理。
    // 3. 对于多维大数组，避免在栈上声明，用vector of vector或一维数组模拟
    // 错误：int hugeMatrix[10000][10000]; // 栈爆炸
    // 正确：
    const int rows = 10000, cols = 10000;
    auto matrix = std::make_unique<int[]>(rows * cols); // 堆上分配
    // 访问元素 matrix[row * cols + col]
}

void readFileDangerously(const std::string& filename) {
    std::ifstream file(filename, std::ios::binary | std::ios::ate);
    if (!file) return;
    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);
    char buffer[size]; // 错误！这是变长数组(VLA)，是C99特性，不属于标准C++。
                        // 即使编译器扩展支持，如此大的数组也在栈上，极其危险！
    file.read(buffer, size);
    // ... 处理buffer
}

#include <fstream>
#include <vector>
#include <iostream>
void processLargeFileSafely(const std::string& filename) {
    const size_t BUFFER_SIZE = 1024 * 1024; // 每次处理1MB
    std::vector<char> buffer(BUFFER_SIZE); // 缓冲区在堆上
    std::ifstream file(filename, std::ios::binary);
    if (!file) {
        throw std::runtime_error("无法打开文件: " + filename);
    }
    while (file) {
        file.read(buffer.data(), buffer.size());
        std::streamsize bytesRead = file.gcount(); // 实际读取的字节数
        if (bytesRead > 0) {
            // 处理这一块数据 buffer[0] 到 buffer[bytesRead-1]
            std::cout << "处理了 " << bytesRead << " 字节数据块。" << std::endl;
            // 你的实际处理逻辑在这里...
        }
    }
    // 循环结束，文件处理完成。buffer会在函数结束时自动释放。
}
// 如果需要更精细的控制，可以使用RAII类封装
class ChunkedFileReader {
public:
    explicit ChunkedFileReader(const std::string& filename, size_t chunkSize = 1024*1024)
        : file_(filename, std::ios::binary), chunkSize_(chunkSize), buffer_(chunkSize) {
        if (!file_.is_open()) {
            throw std::runtime_error("打开文件失败: " + filename);
        }
    }
    bool readNextChunk() {
        file_.read(buffer_.data(), buffer_.size());
        bytesInBuffer_ = file_.gcount();
        return bytesInBuffer_ > 0;
    }
    const char* data() const { return buffer_.data(); }
    size_t size() const { return bytesInBuffer_; }
private:
    std::ifstream file_;
    size_t chunkSize_;
    std::vector<char> buffer_;
    std::streamsize bytesInBuffer_ = 0;
};

#include <memory>
#include <iostream>
#include <cstring> // for memcpy
class BigDataProcessor {
public:
    // 构造函数：分配资源
    BigDataProcessor(size_t dataSize) : size_(dataSize) {
        std::cout << "分配 " << dataSize << " 字节堆内存。" << std::endl;
        data_ = std::make_unique<char[]>(dataSize); // 核心资源：堆内存
        // 这里可以打开文件、网络连接等其他资源...
    }
    // 析构函数：释放资源（自动调用，即使发生异常）
    ~BigDataProcessor() {
        std::cout << "自动释放 " << size_ << " 字节堆内存。" << std::endl;
        // data_ 的 unique_ptr 会自动删除数组，无需手动操作。
        // 这里可以关闭文件、网络连接等...
    }
    // 示例处理函数
    void process() {
        // 模拟一个可能抛出异常的操作
        if (size_ > 100000000) { // 假设处理数据太大，我们“模拟”一个错误
            throw std::runtime_error("数据过大，处理失败！");
        }
        // 正常处理逻辑...
        std::cout << "正在处理数据..." << std::endl;
    }
    // 提供数据访问接口
    char* get() { return data_.get(); }
    size_t size() const { return size_; }
    // 禁止拷贝（因为unique_ptr独占所有权）
    BigDataProcessor(const BigDataProcessor&) = delete;
    BigDataProcessor& operator=(const BigDataProcessor&) = delete;
    // 允许移动
    BigDataProcessor(BigDataProcessor&&) = default;
    BigDataProcessor& operator=(BigDataProcessor&&) = default;
private:
    std::unique_ptr<char[]> data_;
    size_t size_;
};
void useProcessor() {
    try {
        BigDataProcessor processor(1024 * 1024 * 10); // 分配10MB
        // 填充数据（模拟）
        std::memset(processor.get(), 'A', processor.size());
        processor.process(); // 可能抛出异常
        // 如果process()抛出异常，processor的析构函数依然会被调用，内存被安全释放！
    } catch (const std::exception& e) {
        std::cerr << "处理过程中发生异常: " << e.what() << std::endl;
        // 注意：即使在这里，processor的析构函数也已经在栈展开过程中被调用了。
    }
    // 离开try-catch块，processor对象已销毁，资源100%被清理。
}