你的代码在不同大小的矩阵上产生了看似合理的输出，但是它使用了三重嵌套循环来进行交换，而一个循环就足够了，这是一种浪费。它可能对小矩阵不太重要，但对大得多的矩阵就很重要了。
你还应该使用一个函数来打印矩阵，因为m是一个常量，所以你要处理的是定长矩阵，而不是变长矩阵，但是你可以很容易地编写一个打印函数来处理变长矩阵。
例如：

#include <stdio.h>

#define m 4

static void print_matrix(const char *tag, int matrix[m][m])
{
    printf("%s (%dx%d):\n", tag, m, m);
    for (int r = 0; r < m; r++)
    {
        for (int c = 0; c < m; c++)
            printf("%d ", matrix[r][c]);
        printf("\n");
    }
}

int main(void)
{
    int arr[m][m] =
    {
        {1, 2, 3, 5},
        {4, 1, 6, 0},
        {7, 8, 1, 3},
        {0, 5, 4, 1}
    };

    print_matrix("Before", arr);

    /* Swap elements on diagonals */
    for (int i = 0; i < m; i++)
    {
        int k = m - i - 1;
        int temp1 = arr[i][i];
        arr[i][i] = arr[i][k];
        arr[i][k] = temp1;
    }

    printf("\n\n");
    print_matrix("After", arr);

    return 0;
}

输出：

Before (4x4):
1 2 3 5 
4 1 6 0 
7 8 1 3 
0 5 4 1 

After (4x4):
5 2 3 1 
4 6 1 0 
7 1 8 3 
1 5 4 0

这也适用于不同大小的矩阵。
最后，你还需要创建一个函数来交换对角线上的元素，在函数中使用VLA符号，你可以处理任意大小的矩阵，如下所示：

#include <stdio.h>

/* Print square matrix */
static void print_matrix(const char *tag, size_t size, int matrix[size][size])
{
    printf("%s (%zux%zu):\n", tag, size, size);
    for (size_t r = 0; r < size; r++)
    {
        for (size_t c = 0; c < size; c++)
            printf("%d ", matrix[r][c]);
        printf("\n");
    }
}

/* Swap elements on diagonals of a square matrix */
static void swap_diagonals(size_t size, int matrix[size][size])
{
    for (size_t i = 0; i < size; i++)
    {
        size_t k = size - i - 1;
        int t = matrix[i][i];
        matrix[i][i] = matrix[i][k];
        matrix[i][k] = t;
    }
}

int main(void)
{
    enum { SIZE1 = 4, SIZE2 = 5 };
    int arr1[SIZE1][SIZE1] =
    {
        { 1, 2, 3, 5 },
        { 4, 1, 6, 0 },
        { 7, 8, 1, 3 },
        { 0, 5, 4, 1 },
    };
    int arr2[SIZE2][SIZE2] =
    {
        { 1, 2, 3, 4, 5 },
        { 4, 1, 6, 4, 0 },
        { 7, 8, 1, 4, 3 },
        { 0, 5, 4, 1, 1 },
        { 9, 2, 6, 3, 1 },
    };

    print_matrix("Before", SIZE1, arr1);
    swap_diagonals(SIZE1, arr1);
    print_matrix("After", SIZE1, arr1);

    printf("\n\n");

    print_matrix("Before", SIZE2, arr2);
    swap_diagonals(SIZE2, arr2);
    print_matrix("After", SIZE2, arr2);

    return 0;
}

输出：

Before (4x4):
1 2 3 5 
4 1 6 0 
7 8 1 3 
0 5 4 1 
After (4x4):
5 2 3 1 
4 6 1 0 
7 1 8 3 
1 5 4 0 

Before (5x5):
1 2 3 4 5 
4 1 6 4 0 
7 8 1 4 3 
0 5 4 1 1 
9 2 6 3 1 
After (5x5):
5 2 3 4 1 
4 4 6 1 0 
7 8 1 4 3 
0 1 4 5 1 
1 2 6 3 9

这就是为什么你要使用函数--需要的代码要少得多。3行的段落也可以变成一个函数，但现在还不是必要的，而另外两个函数是非常有益的（虽然，我想，你可以多次写出代码，所以这不是很必要，但代码重复的风险是一个长期的维护问题）。
让print_matrix()函数也打印非方阵几乎是微不足道的：

static void print_matrix(const char *tag, size_t rows, size_t cols, int matrix[rows][cols])
{
    printf("%s (%zux%zu):\n", tag, rows, cols);
    for (size_t r = 0; r < rows; r++)
    {
        for (size_t c = 0; c < cols; c++)
            printf("%3d", matrix[r][c]);
        putchar('\n');
    }
}

对于方阵，您需要为rows和cols参数传递相同的大小。