ANSI-C中的模平方校验器

Question

我用C语言编写了一个使用模块化编程的简单程序(使用了很多函数)，它从用户那里获得一行输入，然后打印给定的输入是否形成幻方。

第一个输入是矩阵的顺序，其余的是顺序*顺序输入(阶^2)(整数)，它们实际上是填充矩阵的。例如，如果我输入3 1 2 3 4 5 6 7 8 9，顺序是3，输入是1,..,9。

我不确定的一件事是如何处理小于9的输入。

无论如何，我希望看到你的调整，学习更多，并从你的知识分享中提高。

请记住，它应该是用ANSI-C编写的(我知道它很古老，但这些都是要求)。如果您有一些关于C11或其他方面的很酷的东西要分享，请这样做，因为我喜欢扩展我的知识和提高(即使我现在是一个菜鸟)。

#include <stdio.h>
#include <stdlib.h>
#define MAX 10 /*maximal size of the array*/



void checkOrderRange(int order, int matrix[order][order]); /* checking if number of rows+number of columns is greater than N^2 */
void checkOrderType(int order);                            /*checking if order is a digit*/
void checkOrderSize(int order);                            /*checking if order is in the correct size (bigger than 3 and smaller than selected MAX) */
void scanMatrix(int order, int matrix[order][order]);      /*scans the matrix and assigns given values */
void printMatrix(int order, int matrix[order][order]);     /*prints given matrix*/
int diagonalSumI(int order, int matrix[order][order]);     /*calculates first diagonal sum */
int diagonalSumII(int order, int matrix[order][order]);    /*calculates second diagonal sum */
int columnSumAndCompareToDiagonal(int order, int matrix[order][order]); /*calculates sum of each coloumn and stores in an array*/
int rowSumAndCompareToDiagonal(int order, int matrix[order][order]);    /*calculates sum of each row and stores in an array*/
void checkSum(int order, int matrix[order][order]);                     /*compares above sums to check if it's indeed a magic square*/
int isdigit();
void checkIfMagicSquare(int order, int matrix[order][order]);

int main() {
    int order, matrix[MAX][MAX];
    printf("please enter the order of the magic square \n");
    scanf("%d", &order);
    scanMatrix(order, matrix);
    checkOrderSize(order);
    printf("here's your matrix \n");
    printMatrix(order, matrix);
    columnSumAndCompareToDiagonal(order, matrix);
    rowSumAndCompareToDiagonal(order, matrix);
    checkIfMagicSquare(order,matrix);

    return 0;
}

void scanMatrix(int order, int matrix[order][order]) {
    for (int I = 0; I < order; I++) {
        for (int J = 0; J < order; J++) {
            if (scanf("%d", &matrix[I][J]) != 1) {
                puts("you did not enter an integer(decimal)\n"); /* checking for integer insertion*/
                exit(0);
            }
        }
    }
}

void printMatrix(int order, int matrix[order][order]) {
    for (int I = 0; I < order; I++) {
        for (int J = 0; J < order; J++) {
            printf("%d\t", matrix[I][J]);
        }
        printf("\n");
    }
}

int diagonalSumI(int order, int matrix[order][order]) {
    int diagonal = 0;
    for (int I = 0; I < order; I++) {
        diagonal = diagonal + matrix[I][I];
    }
    return diagonal;
}

int diagonalSumII(int order, int matrix[order][order]) {
    int diagonal2 = 0;
    for (int I = 0, J = order - 1; I < order; I++, J--) {
        diagonal2 = diagonal2 + matrix[I][J];
    }
    return diagonal2;
}

int columnSumAndCompareToDiagonal(int order, int matrix[order][order]) {
    int columnsum[order];
    for (int I = 0; I < order; I++) {
        columnsum[I] = 0;
        for (int J = 0; J < order; J++) {
            columnsum[I] = columnsum[I] + matrix[I][J];
        }
    }
    for (int K = 0; K < order; K++) {
        if (columnsum[K] == diagonalSumI(order, matrix) && diagonalSumI(order, matrix) == diagonalSumII(order, matrix)) {}
        else {
            fprintf(stderr, "Sorry. but not a magic square\n");
            exit(EXIT_FAILURE);
            return 0;
        }

    }
    return 1;
}

int rowSumAndCompareToDiagonal(int order, int matrix[order][order]) {
    int rowsum[order];
    for (int J = 0; J < order; J++) {
        rowsum[J] = 0;
        for (int I = 0; I < order; I++) {
            rowsum[J] = rowsum[J] + matrix[I][J];
        }}
        for (int K = 0; K < order; K++) {
            if (rowsum[K] == diagonalSumI(order, matrix) && diagonalSumI(order, matrix) == diagonalSumII(order, matrix)) {
            } else {
                fprintf(stderr, "Sorry. but not a magic square\n");
                exit(EXIT_FAILURE);
                return 0;
            }

        }
    return 1;
}
void checkIfMagicSquare(int order, int matrix[order][order]) {
    if (rowSumAndCompareToDiagonal(order, matrix) && columnSumAndCompareToDiagonal(order, matrix)) {
        printf("congratulations, it is a magic square \n");
    } else {
        fprintf(stderr, "Sorry. but not a magic square \n");
    }
}

void checkOrderSize(int order) { /*checking if order is in the correct size (bigger than 3 and smaller than selected MAX) */
    if (order < 3 || order > MAX) {
        fprintf(stderr, "order of matrix is either smaller than 3 or larger than %d\n", MAX);
        exit(EXIT_FAILURE);
    }
}

void checkOrderType(int order) { /*checking if order is a digit*/
    if (!isdigit(order)) {
        fprintf(stderr, "Input is not decimal or not a digit\n");
        exit(EXIT_FAILURE);
    }
}

Answer 1

我认为您的代码可以通过为行、元素和列创建foreach函数，并使用它们来实现其他一些函数，从而更加紧凑。伪：

void foreachelement(int* matrix, int order, void* data, void (f*)(int * element, void* data)) {
  for(row...) {
    for(col...) {
      f(matrix_element..., data);
    }
  }
}

void sum(int* element, void* data) {
  *(int*)data += *element;
}

int matrix[3][3]; // todo: set some values
int result = 0;
foreachelement(matrix, 3, &result, sum);

您的错误处理看起来很像断言。添加#include <assert.h>并更改检查(否则将打印为stderr和exit(-1);，类似于：

assert(isdigit(order));

如果需要，可以使用排序操作符和字符串常量轻松地在assert()中插入更详细的消息：

assert(("Input is not decimal or not a digit", isdigit(order));

当我们开发人员首先关注正确的(用户)行为，然后关注错误处理时，assert是一个时间保护程序。此外，有一天，您可能需要将您的代码集成到一个应用程序中，并以管道显示为null或不显示stderr。