如何编写函数填充传入的原数组而非函数参数内的数组？

嘿，这个问题在C++里其实很常见——要让函数直接操作原数组而非内部副本，核心在于传递数组的引用或者指针（传值会创建副本，修改的只是副本而已）。我给你梳理几种靠谱的实现方式，结合你需要的填充、排序功能写了示例代码：

如果你的数组大小固定，或者想让编译器帮你做类型校验，可以用数组引用作为函数参数。要是需要适配不同大小的数组，搭配模板函数就完美了：

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <algorithm> // 用于std::sort排序
using namespace std;

// 模板函数：填充任意大小的int原数组
template <size_t N>
void fillOriginalArray(int (&arr)[N]) {
    srand(time(nullptr)); // 初始化随机数种子
    for (size_t i = 0; i < N; ++i) {
        arr[i] = rand() % 100; // 填充0-99的随机整数
    }
}

// 模板函数：直接对原数组排序
template <size_t N>
void sortOriginalArray(int (&arr)[N]) {
    sort(arr, arr + N); // 操作的就是原数组的内存
}

int main() {
    int myArray[10]; // 定义你的原数组

    // 填充原数组
    fillOriginalArray(myArray);
    cout << "填充后的原数组：";
    for (int num : myArray) cout << num << " ";
    cout << endl;

    // 排序原数组
    sortOriginalArray(myArray);
    cout << "排序后的原数组：";
    for (int num : myArray) cout << num << " ";
    cout << endl;

    return 0;
}

这里的int (&arr)[N]就是数组的引用，函数里对arr的任何修改都会直接作用在传入的原数组上。模板的size_t N会自动推导数组的大小，不用手动传长度，既方便又安全。

如果你的数组是动态分配的（比如用new创建），或者需要更灵活的长度控制，就用指针传递数组，同时传入数组的长度：

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

// 填充原数组：arr是指向原数组的指针，size是数组长度
void fillOriginalArray(int* arr, int size) {
    if (!arr || size <= 0) return; // 边界检查，避免空指针或非法长度
    srand(time(nullptr));
    for (int i = 0; i < size; ++i) {
        arr[i] = rand() % 100;
    }
}

// 排序原数组
void sortOriginalArray(int* arr, int size) {
    if (!arr || size <= 0) return;
    sort(arr, arr + size);
}

int main() {
    int* dynamicArray = new int[15]; // 动态分配的原数组

    fillOriginalArray(dynamicArray, 15);
    cout << "动态数组填充后：";
    for (int i = 0; i < 15; ++i) cout << dynamicArray[i] << " ";
    cout << endl;

    sortOriginalArray(dynamicArray, 15);
    cout << "动态数组排序后：";
    for (int i = 0; i < 15; ++i) cout << dynamicArray[i] << " ";
    cout << endl;

    delete[] dynamicArray; // 记得释放动态分配的内存
    return 0;
}

这种方式不管是静态数组还是动态数组都能处理，不过要注意手动传递长度，还要做好边界检查避免越界访问。

你提到了class Function...，把这些功能封装到类里也很简单，比如：

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

class ArrayHandler {
public:
    // 处理静态数组的模板成员函数：填充
    template <size_t N>
    void fill(int (&arr)[N]) {
        srand(time(nullptr));
        for (size_t i = 0; i < N; ++i) {
            arr[i] = rand() % 100;
        }
    }

    // 处理静态数组的模板成员函数：排序
    template <size_t N>
    void sort(int (&arr)[N]) {
        std::sort(arr, arr + N);
    }

    // 处理动态数组的成员函数：填充
    void fill(int* arr, int size) {
        if (!arr || size <= 0) return;
        srand(time(nullptr));
        for (int i = 0; i < size; ++i) {
            arr[i] = rand() % 100;
        }
    }

    // 处理动态数组的成员函数：排序
    void sort(int* arr, int size) {
        if (!arr || size <= 0) return;
        std::sort(arr, arr + size);
    }
};

int main() {
    ArrayHandler handler;
    int staticArr[8];

    handler.fill(staticArr);
    cout << "静态数组填充后：";
    for (int num : staticArr) cout << num << " ";
    cout << endl;

    handler.sort(staticArr);
    cout << "静态数组排序后：";
    for (int num : staticArr) cout << num << " ";
    cout << endl;

    return 0;
}

关键要点总结 #

• 别直接传数组名（虽然数组名会隐式转成指针，但函数无法知道数组长度，容易越界），要么用引用+模板，要么用指针+长度。
• 数组引用的方式类型更安全，编译器会帮你检查数组类型和大小是否匹配，避免低级错误。
• 不管哪种方式，函数里操作的都是原数组的内存地址，所以修改会直接作用在原数组上。

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