函数在C中分配和修改许多（多个）数组[重复]答案

【问题标题】：Function allocate and modify many (more than one) arrays in C [duplicate]函数在C中分配和修改许多（多个）数组[重复]
【发布时间】：2020-12-04 23:25:09
【问题描述】：

C 函数可以通过传递引用的错觉（Ely 解释的地址传递值）来修改多个变量，例如:

#include <stdio.h>

void function(int *pa, int *pb) {
    *pa *= *pa;
    *pb *= *pb;
}

int main(void) {
    int a = 1, b = 2;
    function(&a, &b);
    printf("a = %d\nb = %d\n", a, b);
    return 0;
}

哪个输出

a = 1
b = 4

还可以通过返回指向数组的指针来修改整个变量范围，例如：

#include <stdlib.h>
#include <stdio.h>

int *function(int *ptr_size) {
    int n = 6;  // arbitrary ptr_size
    int *array = (int *)malloc(n * sizeof(int));
    for (int i = 0; i < n; ++i)
        array[i] = i * i;
    //
    *ptr_size = n;
    return array;
}

int main(void) {
    int size = 0;
    int *array = function(&size);
    printf("size = %d\n", size);
    for (int i = 0; i < size; ++i)
        printf("array[%d] = %d\n", i, array[i]);
    free(array);
    array = NULL;
    return 0;
}

哪个输出：

size = 6
array[0] = 0
array[1] = 1
array[2] = 4
array[3] = 9
array[4] = 16
array[5] = 25

但是如果我想要一个修改多个（动态分配的）数组的函数呢？
我试过这个

#include <stdlib.h>
#include <stdio.h>

void function(int *array, int *ptr_asize, int *brray, int *ptr_bsize) {
    int size = 6;
    array = (int *)malloc(size * sizeof(int));
    brray = (int *)malloc(size * sizeof(int));
    for (int i = 0; i < size; ++i) {
        array[i] = i * i;
        brray[i] = i * i * i;
    }
    *ptr_asize = size;
    *ptr_bsize = size;
}

int main(void) {
    int asize, bsize;
    int *array, *brray;
    function(array, &asize, brray, &bsize);
    // array
    printf("asize = %d\n", asize);
    for (int i = 0; i < asize; ++i)
        printf("array[%d] = %d\n", i, array[i]);
    free(array);
    array = NULL;
    // brray
    printf("bsize = %d\n", bsize);
    for (int i = 0; i < bsize; ++i)
        printf("brray[%d] = %d\n", i, brray[i]);
    free(brray);
    brray = NULL;
    //
    return 0;
}

但它会导致分段错误。
这并不奇怪，main 怎么知道array 和brray 分配了多少内存？

所以我的问题是：在 C 中是否有可能一个函数分配和修改多个数组，而这些更改仍保留在 main 中？

PS：一个解决方案是分配一个新的abrray，其中包含array和brray（int **function(...) { ... return abrray; }），但我想知道一个函数是否可以修改两个（或更多) 数组，并且更改保留在main。

【问题讨论】：

不是真的！实际上，我什至看不到这两个问题之间的关系，除了它们处理指针：-/。我的问题是是否可以在一个函数中分配和修改两个数组，并将这些更改保留在main？，如果可以，如何？
表示你没看懂答案。它准确地告诉您如何通过指针将分配的内存从函数返回给调用者。
没错，这就是我问这个问题的原因！此外，我在任何地方都没有找到分配和修改两个数组的函数示例......
这就是链接帖子告诉您的内容。好的，诚然，它向您展示了如何为一个数组执行此操作。但这是你需要知道的原则。它告诉你如何在函数中分配内存，设置调用者传入的指针，然后调用者可以使用它。它向您展示了一个数组，但任何数量的数组都可以通过传入更多函数参数以相同的方式完成。
我没有给你投反对票——我同意这有点粗略。在这里，有一个upvote :-)

标签： arrays c pointers dynamic-memory-allocation

【解决方案1】：

传递一个指向指针的指针，像这样：

void func(int** array, int** brray, size_t size_a, size_t size_b) {
*array = malloc(size_a * sizeof(int));
*brray = malloc(size_b * sizeof(int));
}

这样称呼：

int *arr, *brr;
func(&arr, &brr, 2, 5);

【讨论】：

值得展示如何调用该函数。
两个代码 sn-ps 不匹配 - 函数参数的数量不同。

【解决方案2】：

正如iTs.SL4y3r 所解释的，可以通过将指针传递给指针。
这是一个最小的工作示例：

#include <stdlib.h>
#include <stdio.h>

void function(int **array, int *ptr_asize, int **brray, int *ptr_bsize) {
    int size = 6;
    *array = malloc(size * sizeof(int));
    *brray = malloc(size * sizeof(int));
    for (int i = 0; i < size; ++i) {
        (*array)[i] = i * i;
        (*brray)[i] = i * i * i;
    }
    *ptr_asize = size;
    *ptr_bsize = size;
}

int main() {
    int asize, bsize;
    int *array, *brray;
    function(&array, &asize, &brray, &bsize);
    // array
    printf("asize = %d\n", asize);
    for (int i = 0; i < asize; ++i)
        printf("array[%d] = %d\n", i, array[i]);
    free(array);
    array = NULL;
    // brray
    printf("bsize = %d\n", bsize);
    for (int i = 0; i < bsize; ++i)
        printf("brray[%d] = %d\n", i, brray[i]);
    free(brray);
    brray = NULL;
    //
    return 0;
}

哪个输出：

asize = 6
array[0] = 0
array[1] = 1
array[2] = 4
array[3] = 9
array[4] = 16
array[5] = 25
bsize = 6
brray[0] = 0
brray[1] = 1
brray[2] = 8
brray[3] = 27
brray[4] = 64
brray[5] = 125

【讨论】：