Can'；t在函数调用中更改动态分配的数组值

我和C有些问题

我的任务是：

创建一个动态分配的矩阵（最大5x5），让用户填写值，然后将其与未分配数组（1D）一起发送给函数，该数组将用于存储矩阵中低于每行平均值的所有值。 1D数组应在主函数中定义，并在查找所需元素的函数中分配

这一切都很顺利，我制作了我的矩阵，我将它发送给前面提到的函数，但我无法更改新分配的1D数组的值

---

而不是

*p[counter++]

它输出：7-2467754-2467754

---

我做错了什么？我认为分配是正确的，我可以访问*（p+n），但它没有任何作用…

最简单的方法可能是创建一个一维数组，该数组足够大，可以存储数组中的所有元素，然后在遍历二维数组的每一行时填充一维数组。完成二维数组后，将需要的值复制到足够长的数组中并返回

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

int lower_than_average(int **matrix, int **p, int m, int n) {
    int i, j, sum;
    float average;
    int count = 0, counter = 0;

    int *buff;
    buff = (int *)malloc(m * n * sizeof(int));
    if (NULL == buff)
    {
        return (-1);  //return negative value to show an error occurred
    }

    for (i = 0; i < m; i++) {
        sum = 0;

        for (j = 0; j < n; j++) sum += matrix[i][j];
        average = (float)sum / n;

        for (j = 0; j < n; j++){
            if (matrix[i][j] < average) 
            {
                buff[count] = matrix[i][j];
                count++;
            }
        }
    }

    *p = (int*)malloc(count * sizeof(int));
    if(NULL == *p)
    {
        free(buff);
        return (-1);  //return negative value to show an error occurred
    }
    memcpy(*p, buff, count*sizeof(int));
    free(buff);

    printf("\n\n");

    return(count);
}

void print_matrix(int **matrix, int m, int n) {
    int i, j;
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n\n");
    }
}

int main(void) {
    int m, n, **matrix, *elements_a = NULL;
    int i, j, elements_a_size;

    do {
        printf("Enter the number of rows and columns [max 5x5]: ");
        scanf("%d %d", &m, &n);
    } while (n > 5 || n < 0 || m > 5 || m < 0);

    matrix = (int**)malloc(m * sizeof(int*)); // Alokacija redaka

    /*

        X | <empty>
        X | <empty>
        X | <empty>
        X | <empty>

    */

    for (i = 0; i < m; i++) matrix[i] = (int*)calloc(n, sizeof(int)); // Alokacija stupaca

    /*

        X | Y Y Y Y Y Y
        X | Y Y Y Y Y Y
        X | Y Y Y Y Y Y
        X | Y Y Y Y Y Y

    */

    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("Enter [%d][%d] element: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    printf("\n\n");

    print_matrix(matrix, m, n);

    elements_a_size = lower_than_average(matrix, &elements_a, m, n);

    printf("\nElements of rows smaller than the row average value: ");
    for (i = 0; i < elements_a_size; i++) printf("%d ", elements_a[i]);

    printf("\n");  //a new line so the prompt isn't on the same line as the output

    for (i = 0; i < m; i++) free(matrix[i]);
    free(matrix);
    free(elements_a);  //also free the memory dynamically allocated in the function!

    return 0;
}

---

最简单的方法可能是创建一个足够大的一维数组来存储数组中的所有元素，然后在遍历二维数组的每一行时填充一维数组。完成二维数组后，将需要的值复制到足够长的数组中并返回

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

int lower_than_average(int **matrix, int **p, int m, int n) {
    int i, j, sum;
    float average;
    int count = 0, counter = 0;

    int *buff;
    buff = (int *)malloc(m * n * sizeof(int));
    if (NULL == buff)
    {
        return (-1);  //return negative value to show an error occurred
    }

    for (i = 0; i < m; i++) {
        sum = 0;

        for (j = 0; j < n; j++) sum += matrix[i][j];
        average = (float)sum / n;

        for (j = 0; j < n; j++){
            if (matrix[i][j] < average) 
            {
                buff[count] = matrix[i][j];
                count++;
            }
        }
    }

    *p = (int*)malloc(count * sizeof(int));
    if(NULL == *p)
    {
        free(buff);
        return (-1);  //return negative value to show an error occurred
    }
    memcpy(*p, buff, count*sizeof(int));
    free(buff);

    printf("\n\n");

    return(count);
}

void print_matrix(int **matrix, int m, int n) {
    int i, j;
    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n\n");
    }
}

int main(void) {
    int m, n, **matrix, *elements_a = NULL;
    int i, j, elements_a_size;

    do {
        printf("Enter the number of rows and columns [max 5x5]: ");
        scanf("%d %d", &m, &n);
    } while (n > 5 || n < 0 || m > 5 || m < 0);

    matrix = (int**)malloc(m * sizeof(int*)); // Alokacija redaka

    /*

        X | <empty>
        X | <empty>
        X | <empty>
        X | <empty>

    */

    for (i = 0; i < m; i++) matrix[i] = (int*)calloc(n, sizeof(int)); // Alokacija stupaca

    /*

        X | Y Y Y Y Y Y
        X | Y Y Y Y Y Y
        X | Y Y Y Y Y Y
        X | Y Y Y Y Y Y

    */

    for (i = 0; i < m; i++) {
        for (j = 0; j < n; j++) {
            printf("Enter [%d][%d] element: ", i, j);
            scanf("%d", &matrix[i][j]);
        }
    }

    printf("\n\n");

    print_matrix(matrix, m, n);

    elements_a_size = lower_than_average(matrix, &elements_a, m, n);

    printf("\nElements of rows smaller than the row average value: ");
    for (i = 0; i < elements_a_size; i++) printf("%d ", elements_a[i]);

    printf("\n");  //a new line so the prompt isn't on the same line as the output

    for (i = 0; i < m; i++) free(matrix[i]);
    free(matrix);
    free(elements_a);  //also free the memory dynamically allocated in the function!

    return 0;
}

---

你必须换线

 *p[counter++] = matrix[i][j];

借

因为[]优先于*

---

请参阅：

您必须更改行

 *p[counter++] = matrix[i][j];

借

因为[]优先于*

---

请参阅：

*p[counter++]

此处的优先错误<代码>[]的优先级高于

*

。你最终得到的是int**算法，这并不是你想要的。为什么要对一维矩阵使用双指针（

**p

）？一个指向

int

的常规指针就足够了。试试

（*p）[counter++]

你忘记了

free（p）

或

free（elements_A）

@MatijaNovosel是的，

p

的双指针就可以了，如果你需要将地址返回给调用者。但是，指针数组不是2D数组，这在我发布的链接中有解释。

*p[counter++]

这里的优先级错误<代码>[]的优先级高于

*

。你最终得到的是int**算法，这并不是你想要的。为什么要对一维矩阵使用双指针（

**p

）？一个指向

int

的常规指针就足够了。试试

（*p）[counter++]

你忘记了

free（p）

或

free（elements_A）

@MatijaNovosel是的，

p

的双指针就可以了，如果你需要将地址返回给调用者。然而，指针数组不是2D数组，这在我发布的链接中有解释。不是我的，但可能是因为提供稍微不同的解决方案并不能回答问题。对不起，我的错误。谢谢你的回答。不是我的，但可能是因为提供稍微不同的解决方案并不能回答问题。对不起，我错了。谢谢你的回答。

 *p[counter++] = matrix[i][j];

 (*p)[counter++] = matrix[i][j];