数组顺时针旋转代码出现Segmentation Error，请求问题定位

嘿，我来帮你分析下这段代码触发Segmentation Error的几个核心问题，以及对应的修复方法：

问题1：静态数组temp大小硬编码，超出范围直接越界 #

你在rotate函数里定义了static int temp[100];，这个数组的大小固定死是100。如果测试用例里的旋转次数m（也就是题目里的D）超过100，第一个循环for(int i =0;i<m;i++) temp[i]=ar[i];就会往temp的内存范围外写数据，破坏程序的静态存储区，直接触发段错误。这应该是你当前遇到问题的最主要原因。

问题2：C++中不标准的变长数组（VLA） #

main函数里的int arr[n];是C语言的特性，C++标准里根本没有这个语法。虽然部分编译器（比如GCC）会兼容支持，但它是在栈上分配内存的——栈的空间本来就很小，如果n的数值比较大，很容易出现栈溢出，这也是段错误的常见诱因。

问题3：未处理m > n的潜在风险 #

题目要求旋转D个元素，当D大于数组长度N时，其实等价于旋转D%N个元素（比如数组长度5，旋转7次和旋转2次效果完全一样）。如果不做这个处理，当m > n时，后续的数组下标计算会出现负数或者超出范围的情况，同样可能触发段错误。

修复后的代码 #

针对上面的问题，我给你两种修复方案，一种是更符合C++风格的vector写法，另一种是基于指针和动态内存的写法：

方案1：使用std::vector（推荐） #

vector会自动管理内存，避免手动分配释放的麻烦，也更安全：

#include <iostream>
#include <vector>
using namespace std;

vector<int> rotate(vector<int> ar, int n, int m) {
    // 处理旋转次数大于数组长度的情况
    m = m % n;
    // 直接用vector截取前m个元素作为临时存储
    vector<int> temp(ar.begin(), ar.begin() + m);
    
    // 将后面的元素向前移动m位
    for(int j = m; j < n; j++) {
        ar[j - m] = ar[j];
    }
    
    // 将临时元素放到数组末尾
    int x = 0;
    for(int k = n - m; k < n; k++) {
        ar[k] = temp[x];
        x++;
    }
    return ar;
}

int main() {
    int t, n , m;
    cin >> t;
    while(t > 0) {
        cin >> n >> m;
        vector<int> arr(n);
        for(int i = 0 ; i < n; i++) {
            cin >> arr[i];
        }
        vector<int> result = rotate(arr, n, m);
        for(int num : result)
            cout << num << " ";
        cout << endl;
        t--;
    }
    return 0;
}

方案2：使用动态内存分配（如果你更习惯指针写法） #

这种写法需要手动管理内存，记得用完后释放：

#include <iostream>
#include <cstdlib>
using namespace std;

int* rotate(int ar[], int n, int m) {
    // 处理旋转次数超出数组长度的情况
    m = m % n;
    // 动态分配对应大小的临时数组
    int* temp = (int*)malloc(m * sizeof(int));
    for(int i = 0; i < m; i++) {
        temp[i] = ar[i];
    }
    
    // 前移元素
    for(int j = m; j < n; j++) {
        ar[j - m] = ar[j];
    }
    
    // 填充临时元素到末尾
    int x = 0;
    for(int k = n - m; k < n; k++) {
        ar[k] = temp[x];
        x++;
    }
    free(temp); // 必须释放动态分配的内存，避免泄漏
    return ar;
}

int main() {
    int t, n , m;
    cin >> t;
    while(t > 0) {
        cin >> n >> m;
        // 动态分配数组，代替变长数组
        int* arr = (int*)malloc(n * sizeof(int));
        for(int i = 0 ; i < n; i++) {
            cin >> arr[i];
        }
        int* ptr = rotate(arr, n, m);
        for(int j = 0; j < n; j++)
            cout << ptr[j] << " ";
        cout << endl;
        free(arr); // 释放数组内存
        t--;
    }
    return 0;
}

额外提示 #

• 优先用std::vector，它是C标准库的容器，比手动管理内存更可靠，也更符合现代C的写法。
• 不管用哪种方式，处理m % n都是必要的，它能避免很多越界问题。
• 静态数组的大小永远不要硬编码成固定值，否则遇到超出范围的输入就会出问题。

内容的提问来源于stack exchange，提问作者Prerna Sharma