1． 利用指针计算2个矩阵的和。

### 回答1：
假设两个矩阵均为 $m$ 行 $n$ 列的矩阵，可以定义一个函数如下：

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

void add_matrices(int **mat1, int **mat2, int **result, int m, int n) {
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
}

其中，`mat1` 和 `mat2` 分别为两个矩阵的指针数组，`result` 为结果矩阵的指针数组，`m` 和 `n` 分别为矩阵的行数和列数。在主函数中，可以先动态分配这些矩阵的空间，然后赋值并输出结果，示例代码如下：

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

void add_matrices(int **mat1, int **mat2, int **result, int m, int n);

int main() {
    int m = 2, n = 3;
    int **mat1, **mat2, **result;

    // 动态分配矩阵空间
    mat1 = (int **) malloc(m * sizeof(int *));
    mat2 = (int **) malloc(m * sizeof(int *));
    result = (int **) malloc(m * sizeof(int *));
    for (int i = 0; i < m; i++) {
        mat1[i] = (int *) malloc(n * sizeof(int));
        mat2[i] = (int *) malloc(n * sizeof(int));
        result[i] = (int *) malloc(n * sizeof(int));
    }

    // 赋值
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            mat1[i][j] = i + j;
            mat2[i][j] = i - j;
        }
    }

    // 计算矩阵和
    add_matrices(mat1, mat2, result, m, n);

    // 输出结果
    printf("mat1:\n");
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", mat1[i][j]);
        }
        printf("\n");
    }
    printf("mat2:\n");
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", mat2[i][j]);
        }
        printf("\n");
    }
    printf("result:\n");
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }

    // 释放矩阵空间
    for (int i = 0; i < m; i++) {
        free(mat1[i]);
        free(mat2[i]);
        free(result[i]);
    }
    free(mat1);
    free(mat2);
    free(result);

    return 0;
}

void add_matrices(int **mat1, int **mat2, int **result, int m, int n) {
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            result[i][j] = mat1[i][j] + mat2[i][j];
        }
    }
}

输出结果为：

mat1:
0 1 2
1 2 3
mat2:
0 -1 -2
1 0 -1
result:
0 0 0
2 2 2

### 回答2：
要利用指针计算两个矩阵的和，首先我们需要先定义两个矩阵，如下所示：

int matrix1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int matrix2[3][3] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};

然后，我们需要声明一个新的矩阵来保存计算结果：

int result[3][3];

接下来，我们可以利用指针和循环来计算两个矩阵的和，并将结果保存到新的矩阵中：

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        int sum = *(*(matrix1 + i) + j) + *(*(matrix2 + i) + j);
        *(*(result + i) + j) = sum;
    }
}

在上述代码中，`*(*(matrix1 + i) + j)`和`*(*(matrix2 + i) + j)`分别表示matrix1和matrix2中对应位置的元素，`*(*(result + i) + j)`表示result中对应位置的元素。由于矩阵在内存中是以连续的一维数组存储的，我们可以通过指针加减操作来访问矩阵中的元素。

最后，我们可以打印出计算结果，如下所示：

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        cout << result[i][j] << " ";
    }
    cout << endl;
}

这样，我们就可以利用指针计算两个矩阵的和，并将结果保存并打印出来。

### 回答3：
利用指针计算两个矩阵的和可以按照以下步骤进行操作：

1. 首先，定义两个矩阵matrixA和matrixB，分别用来存储两个待求和的矩阵。定义矩阵的行数rowCount和列数colCount。

2. 动态分配内存来存储矩阵matrixA和matrixB，确保能够存储所需的元素数量，即rowCount * colCount。同时，定义一个指向矩阵元素的指针ptrA和ptrB。

3. 使用循环结构，依次输入矩阵matrixA和matrixB的元素值。

4. 定义一个新的矩阵matrixSum，用来存储两个矩阵的和。同时，动态分配内存给matrixSum，确保能够存储所需的元素数量。

5. 定义一个指向矩阵元素的指针ptrSum，将其指向矩阵matrixSum。

6. 使用嵌套的循环结构，遍历matrixA和matrixB的每一个元素，将对应位置的元素相加，并将结果存储到matrixSum中。具体地，可以通过使用指针进行索引，例如ptrSum[i * rowCount + j] = ptrA[i * rowCount + j] + ptrB[i * rowCount + j]，其中i代表行索引，j代表列索引。

7. 打印输出矩阵matrixSum中的元素值，验证计算结果是否正确。

8. 释放动态分配的内存空间，包括matrixA、matrixB和matrixSum。

通过以上步骤，就可以使用指针计算两个矩阵的和。指针的使用可以提高程序的效率，并且节约内存空间的使用。