找到分钟。没有指针的几个矩阵中的值

Question

您能帮我找到适合我的程序的方法吗？在这个程序中，我需要找到我的矩阵的最小值，并比较它们，然后找到最大值中的最大值。我用指针做了它

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

int ch_data(const int,const int,const int,const int);
int** my_array(const int,const int);
void numbers_for_my_array(int** const,const int,const int);
void print_my_array(int** const,const int, const int);
void min_my_array(int** const ,const int ,const int, int*, int*, int*);
int my_mod(int);
int comp_my_array (int,int,int);



int main()
{
    int N,M,L,K,**a=NULL,**b=NULL,**c=NULL,B;

    printf("%s",read);
    while (1){
    printf("Enter N: ");
    scanf("%d",&N);
    printf("Enter M: ");
    scanf("%d",&M);
    printf("Enter L: ");
    scanf("%d",&L);
    printf("Enter K: ");
    scanf("%d",&K);
    printf("\n\n");

        if (ch_data(N,M,L,K)){
        break;
        }
    }


    int* min_i_a_p, *min_j_a_p, *min_value_a_p;
    int* min_i_b_p, *min_j_b_p, *min_value_b_p;
    int* min_i_c_p, *min_j_c_p, *min_value_c_p;

    int min_i_a = 0, min_j_a = 0, min_value_a = 0;
    int min_i_b = 0, min_j_b = 0, min_value_b = 0;
    int min_i_c = 0, min_j_c = 0, min_value_c = 0;

    min_i_a_p = &min_i_a;
    min_j_a_p = &min_j_a;
    min_i_b_p = &min_i_b;
    min_j_b_p = &min_j_b;
    min_i_c_p = &min_i_c;
    min_j_c_p = &min_j_c;

    min_value_a_p = &min_value_a;
    min_value_b_p = &min_value_b;
    min_value_c_p = &min_value_c;


    a=my_array(N,M);
    numbers_for_my_array(a,N,M);
    print_my_array(a,N,M);
    min_my_array(a, N, M, min_i_a_p, min_j_a_p, min_value_a_p);

    b=my_array(M,L);
    numbers_for_my_array(b,M,L);
    print_my_array(b,M,L);
    min_my_array(b, M, L, min_i_b_p, min_j_b_p, min_value_b_p);

    c=my_array(L,K);
    numbers_for_my_array(c,L,K);
    print_my_array(c,L,K);
    min_my_array(b, M, L, min_i_c_p, min_j_c_p, min_value_c_p);

    printf("min of a[%d][%d]- %d \n", *min_i_a_p, *min_j_a_p, *min_value_a_p);
    printf("min of b[%d][%d]- %d \n", *min_i_b_p, *min_j_b_p, *min_value_b_p);
    printf("min of c[%d][%d]- %d \n", *min_i_c_p, *min_j_c_p, *min_value_c_p);

     B=comp_my_array(*min_value_a_p, *min_value_b_p,*min_value_c_p);

    printf("B = %d",B);



    return 0;
}

int ch_data(int N,int M, int L,int K){
    if((N*M<=300)&&(M*L<=300)&&(K*L<=300)){
        return 1;
    }
    else return 0;
}

int** my_array(const int x, const int y){
    int **array=NULL,i;
    if(!(array=(int**)malloc(x*sizeof(int*)))){
        printf("Error memory");
        exit(0);
        }
    for(i=0;i<x;i++){
        if(!(*(array+i)=(int*)malloc(y*sizeof(int)))){
            printf("Error memory");
            exit(0);
        }
    }
return array;
}

void numbers_for_my_array( int** const a ,const int x,const int y){
    srand(time(NULL));
    int i,j;
    for (i=0;i<x;i++){
        for(j=0;j<y;j++){
            a[i][j]=rand()%100;
        }
    }

}

void print_my_array (int** const array, const int x, const int y)
{
    int i, j;
    for(i=0;i<x;i++)
    {
        for(j=0;j<y;j++)
        {
            printf("%d ", array[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void min_my_array (int** const a,const int N,const int M, int* min_i, int* min_j, int* min_value)
{
    int i, j,min_a;
    min_a=a[0][0];
    *min_value = min_a;
    for(i=0;i<N;i++)
    {
        for(j=0;j<M;j++)
        {
            if (my_mod(a[i][j])<min_a)
            {
                min_a = my_mod(a[i][j]);
                *min_value = a[i][j];
                *min_i = i;
                *min_j = j;
                *min_value=min_a;
            }
        }
    }
}

int comp_my_array (int min_value_a,int min_value_b,int min_value_c){

    int s1,s2,s3;
    s1=min_value_a;
    s2=min_value_b;
    s3=min_value_c;
    return (s1> s2)? ((s1>s3)? s1 : s3) : ((s2 > s3)? s2 : s3);
}

int my_mod(int x){
    return (x>=0)? x:-x;}

Answer 1

首先，您的程序无法编译。这很容易修复，并且可能是拼写错误的结果。在main() 的开头你有：

printf("%s", read);

但是read 是未定义的，我不知道你想在这里打印什么。删除这条语句（或定义read）解决了这个问题。

接下来，当我用 3X3“数组”尝试这段代码时，它们三个都具有相同的元素！这是因为您已经在 numbers_for_my_array() 函数中调用了 srand()。该函数被快速连续调用 3 次，因此 rand() 每次都以相同的值作为种子。 time() 返回的值在这个短时间间隔内没有改变。你只需要调用一次srand()，你应该在main()的开头调用。

您在处理第三个“数组”c 时出错。你需要改变：

min_my_array(b, M, L, min_i_c_p, min_j_c_p, min_value_c_p);

到：

min_my_array(c, L, K, min_i_c_p, min_j_c_p, min_value_c_p);

您有内存泄漏，因为您在程序结束时没有free 任何内存分配。规则是，每次调用malloc() 一个free：

/* Free allocated memory */
for (int i = 0; i < N; i++) {
    free(a[i]);
}
free(a);

for (int i = 0; i < M; i++) {
    free(b[i]);
}
free(b);

for (int i = 0; i < L; i++) {
    free(c[i]);
}
free(c);

您可以将此功能封装在一个小函数中，以 free 分配给每个“数组”的内存。

您应该考虑将size_t 用于array dimensions and indices。它是一个无符号整数类型，保证可以保存任何数组索引值。

现在，您使用动态分配创建的不是数组，而是模拟数组。这种技术很容易出错，并且很容易导致内存泄漏（就像您所做的那样）。您应该为此使用可变长度数组（VLA）。它们易于使用，并且由于它们具有自动存储期限，因此不需要重新分配。

要将您的代码转换为使用 VLA，可以删除 my_array() 函数，并且应该更改这些函数签名：

void numbers_for_my_array(const int rows, const int cols, int arr[rows][cols]);
void print_my_array(const int rows, const int cols, int arr[rows][cols]);
void min_my_array(const int rows, const int cols, int arr[rows][cols], int *min_i, int *min_j, int *min_val);

使用 VLA 的函数要求在函数原型的参数中出现 VLA 本身之前声明指定 VLA 尺寸的变量。

然后您将在如下函数中使用这些 VLA：

int a[N][M];
numbers_for_my_array(N, M, a);
print_my_array(N, M, a);
min_my_array(N, M, a, min_i_a_p, min_j_a_p, min_value_a_p);

将代码转换为 VLA 有一个棘手的方面：您拥有的动态数组是由指向 const 值的指针组成的，因此 const int 的二维数组似乎是一个合理的选择。当然，numbers_for_my_array() 函数会更改数组，但 print_my_array() 和 min_my_array() 不会。在这些函数原型中声明const int arr[rows][cols] 会很好。棘手的部分是，这些数组衰减为函数调用中的指针，而 C 会将 ints 的一维数组转换为 const ints 的数组（因为该数组衰减为指向 int 的指针, 它被转换为指向const int) 的指针，它会在将ints 的二维数组转换为const ints 的二维数组时发出警告。 Here is a link that discusses the issue in more detail.。代码仍然可以编译，但是要摆脱警告，您需要进行丑陋的强制转换，以将类型显式转换为函数所期望的类型：

print_my_array(N, M, (const int (*)[M]) a);
min_my_array(N, M, (const int (*)[M]) a, min_i_a_p, min_j_a_p, min_value_a_p);

或者你可以完全放弃 const 限定符，如果这对你来说太难看的话。

这应该可以让你稍微简化你的代码，并且没有更多的内存分配麻烦！附带说明一下，在函数原型中使用变量名来记录函数的使用是一个好主意，尤其是对于带有多个参数的函数。

这是您的程序修改为使用 VLA；这个版本确实在print_my_array() 和min_my_array() 函数中使用了const int 的数组：

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

int ch_data(const int,const int,const int,const int);
void numbers_for_my_array(const int rows, const int cols, int arr[rows][cols]);
void print_my_array(const int rows, const int cols, const int arr[rows][cols]);
void min_my_array(const int rows, const int cols, const int arr[rows][cols], int *min_i, int *min_j, int *min_val);
int my_mod(int);
int comp_my_array (int,int,int);



int main()
{
    int N, M, L, K, B;

    srand(time(NULL));              // moved from numbers_for_my_array()

    while (1){
        printf("Enter N: ");
        scanf("%d",&N);
        printf("Enter M: ");
        scanf("%d",&M);
        printf("Enter L: ");
        scanf("%d",&L);
        printf("Enter K: ");
        scanf("%d",&K);
        printf("\n\n");

        if (ch_data(N,M,L,K)){
            break;
        }
    }


    int* min_i_a_p, *min_j_a_p, *min_value_a_p;
    int* min_i_b_p, *min_j_b_p, *min_value_b_p;
    int* min_i_c_p, *min_j_c_p, *min_value_c_p;

    int min_i_a = 0, min_j_a = 0, min_value_a = 0;
    int min_i_b = 0, min_j_b = 0, min_value_b = 0;
    int min_i_c = 0, min_j_c = 0, min_value_c = 0;

    min_i_a_p = &min_i_a;
    min_j_a_p = &min_j_a;
    min_i_b_p = &min_i_b;
    min_j_b_p = &min_j_b;
    min_i_c_p = &min_i_c;
    min_j_c_p = &min_j_c;

    min_value_a_p = &min_value_a;
    min_value_b_p = &min_value_b;
    min_value_c_p = &min_value_c;

    int a[N][M];
    numbers_for_my_array(N, M, a);
    print_my_array(N, M, (const int (*)[M]) a);
    min_my_array(N, M, (const int (*)[M]) a, min_i_a_p, min_j_a_p, min_value_a_p);

    int b[M][L];
    numbers_for_my_array(M, L, b);
    print_my_array(M, L, (const int (*)[L]) b);
    min_my_array(M, L, (const int (*)[L]) b, min_i_b_p, min_j_b_p, min_value_b_p);

    int c[L][K];
    numbers_for_my_array(L, K, c);
    print_my_array(L, K, (const int (*)[K]) c);
    min_my_array(L, K, (const int (*)[K]) c, min_i_c_p, min_j_c_p, min_value_c_p);

    printf("min of a[%d][%d]- %d \n", *min_i_a_p, *min_j_a_p, *min_value_a_p);
    printf("min of b[%d][%d]- %d \n", *min_i_b_p, *min_j_b_p, *min_value_b_p);
    printf("min of c[%d][%d]- %d \n", *min_i_c_p, *min_j_c_p, *min_value_c_p);

    B=comp_my_array(*min_value_a_p, *min_value_b_p,*min_value_c_p);

    printf("B = %d\n",B);

    return 0;
}

int ch_data(int N,int M, int L,int K){
    if((N*M<=300)&&(M*L<=300)&&(K*L<=300)){
        return 1;
    }
    else return 0;
}

void numbers_for_my_array(const int rows, const int cols, int arr[rows][cols])
{
    int i,j;
    for (i=0;i<rows;i++){
        for(j=0;j<cols;j++){
            arr[i][j]=rand()%100;
        }
    }

}


void print_my_array(const int rows, const int cols, const int arr[rows][cols])
{
    int i, j;
    for(i=0;i<rows;i++)
    {
        for(j=0;j<cols;j++)
        {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

void min_my_array(const int rows, const int cols, const int arr[rows][cols], int *min_i, int *min_j, int *min_value)
{
    int i, j,min_a;
    min_a=arr[0][0];
    *min_value = min_a;
    for(i=0;i<rows;i++)
    {
        for(j=0;j<cols;j++)
        {
            if (my_mod(arr[i][j])<min_a)
            {
                min_a = my_mod(arr[i][j]);
                *min_value = arr[i][j];
                *min_i = i;
                *min_j = j;
                *min_value=min_a;
            }
        }
    }
}

int comp_my_array (int min_value_a,int min_value_b,int min_value_c){

    int s1,s2,s3;
    s1=min_value_a;
    s2=min_value_b;
    s3=min_value_c;
    return (s1> s2)? ((s1>s3)? s1 : s3) : ((s2 > s3)? s2 : s3);
}

int my_mod(int x){
    return (x>=0)? x:-x;}