从主程序中输入一个3*5的整形矩阵，调用一个函数，将此矩阵转置，用指针作为函数的形参，在主程序中输出转置后的矩阵。

### 回答1：
可以先定义一个3*5的整型矩阵，然后在主程序中输入矩阵的元素值。接着，定义一个函数，函数的形参为指向整型数组的指针，函数的功能是将矩阵转置。在函数中，可以使用两个循环来实现矩阵转置的操作。最后，在主程序中调用函数，并输出转置后的矩阵。具体代码如下：

#include <stdio.h>

void transpose(int (*matrix)[5]) {
    int temp;
    for (int i = 0; i < 3; i++) {
        for (int j = i+1; j < 5; j++) {
            temp = matrix[i][j];
            matrix[i][j] = matrix[j][i];
            matrix[j][i] = temp;
        }
    }
}

int main() {
    int matrix[3][5];
    printf("请输入3*5的整型矩阵：\n");
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 5; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }
    transpose(matrix);
    printf("转置后的矩阵为：\n");
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix[j][i]);
        }
        printf("\n");
    }
    return 0;
}

在上面的代码中，函数transpose的形参为指向整型数组的指针，即`int (*matrix)[5]`。在函数中，使用两个循环来实现矩阵转置的操作。循环变量i表示行数，循环变量j表示列数。在每次循环中，将矩阵中第i行第j列的元素与第j行第i列的元素交换即可。

在主程序中，先定义一个3*5的整型矩阵，然后使用两个循环来输入矩阵的元素值。接着，调用函数transpose来转置矩阵。最后，使用两个循环来输出转置后的矩阵。循环变量i表示列数，循环变量j表示行数。在每次循环中，输出矩阵中第j行第i列的元素即可。

### 回答2：
在进行题目的解答之前，我们先来了解一下矩阵的转置。

矩阵的转置指的是将矩阵的行和列对调，得到一个新的矩阵。例如，对于一个3*5的矩阵A：

1 2 3 4 5

6 7 8 9 10

11 12 13 14 15

对其进行转置后，得到一个5*3的矩阵B：

1 6 11

2 7 12

3 8 13

4 9 14

5 10 15

接下来，我们来看如何实现矩阵的转置。

1. 主程序输入矩阵

首先，我们需要在主程序中输入一个3*5的整形矩阵。可以使用二维数组来表示这个矩阵，代码如下：

int matrix[3][5];
for(int i=0; i<3; i++){
  for(int j=0; j<5; j++){
    cin >> matrix[i][j];
  }
}

2. 编写转置函数

接下来，我们需要编写一个函数来实现矩阵的转置。在本题中，要求使用指针作为函数的形参。这个函数需要接收一个3*5的整形矩阵，将其转置后，存储在另一个3*5的整形矩阵中。

函数的代码如下：

void transpose(int (*a)[5], int (*b)[5]){
  for(int i=0; i<3; i++){
    for(int j=0; j<5; j++){
      *(b[j]+i) = *(a[i]+j);
    }
  }
}

这里使用了指针的方式来访问矩阵元素。在二维数组中，每一行的首地址都可以看做一个指针，因此可以使用指针算术来遍历整个矩阵。

3. 在主程序中调用转置函数

在主程序中，我们可以定义一个另一个3*5的整形矩阵C，然后将输入的矩阵A传递给转置函数，最后将转置后的矩阵存储到矩阵C中。

代码如下：

int matrixC[3][5];
transpose(matrix, matrixC);

cout << "转置后的矩阵为：" << endl;
for(int i=0; i<5; i++){
  for(int j=0; j<3; j++){
    cout << matrixC[j][i] << " ";
  }
  cout << endl;
}

4. 输出转置后的矩阵

最后，我们可以在主程序中输出转置后的矩阵。在输出时，需要先遍历列，再遍历行，以便得到正确的矩阵形式。

完整的代码如下：

#include <iostream>
using namespace std;

void transpose(int (*a)[5], int (*b)[5]){
  for(int i=0; i<3; i++){
    for(int j=0; j<5; j++){
      *(b[j]+i) = *(a[i]+j);
    }
  }
}

int main(){
  int matrix[3][5];
  for(int i=0; i<3; i++){
    for(int j=0; j<5; j++){
      cin >> matrix[i][j];
    }
  }

  int matrixC[3][5];
  transpose(matrix, matrixC);

  cout << "转置后的矩阵为：" << endl;
  for(int i=0; i<5; i++){
    for(int j=0; j<3; j++){
      cout << matrixC[j][i] << " ";
    }
    cout << endl;
  }

  return 0;
}

通过这个例子，我们学习了如何使用指针作为函数形参，并且掌握了矩阵转置的实现方法。

### 回答3：
要实现矩阵转置的功能，需要编写一个函数，并将原始矩阵作为参数传递给函数。在函数中，使用指针对原始矩阵进行操作，将其转置。最后，将转置后的矩阵作为返回值返回到主程序中，并输出结果。

具体实现步骤如下：

1. 在主程序中，定义一个3*5的二维整数数组matrix，并对其进行赋值。如下所示：

int matrix[3][5] = {{1,2,3,4,5},
                    {6,7,8,9,10},
                    {11,12,13,14,15}};

2. 定义矩阵转置的函数transpose，并将原始矩阵作为形参传递给函数。函数定义如下：

void transpose(int (*p)[5]);

3. 在函数内部，使用指针对矩阵进行转置。转置的具体实现方式为：将矩阵的行列索引互换，并将矩阵元素赋值给原始矩阵相应位置的元素。函数实现如下所示：

void transpose(int (*p)[5])
{
    int temp; // 用于暂存元素
    for(int i=0;i<3;i++) {
        for(int j=i+1;j<5;j++) {
            temp = p[i][j];
            p[i][j] = p[j][i];
            p[j][i] = temp;
        }
    }
}

注意，在定义函数transpose时，需要声明形参为指针类型，其中指针类型的含义为指向一个包含5个整数的数组的指针。

4. 在主程序中，调用transpose函数，并将矩阵作为实参传递给函数。如下所示：

transpose(matrix);

5. 输出转置后的矩阵。在主程序中，使用循环遍历转置后的矩阵，并输出每个元素的值。代码实现如下：

for(int i=0;i<5;i++) {
    for(int j=0;j<3;j++) {
        printf("%d ",matrix[j][i]);
    }
    printf("\n");
}

完整代码如下：

#include <stdio.h>

void transpose(int (*p)[5]);

int main(void)
{
    int matrix[3][5] = {{1,2,3,4,5},
                        {6,7,8,9,10},
                        {11,12,13,14,15}};
    transpose(matrix);

    for(int i=0;i<5;i++) {
        for(int j=0;j<3;j++) {
            printf("%d ",matrix[j][i]);
        }
        printf("\n");
    }

    return 0;
}

void transpose(int (*p)[5])
{
    int temp; // 用于暂存元素
    for(int i=0;i<3;i++) {
        for(int j=i+1;j<5;j++) {
            temp = p[i][j];
            p[i][j] = p[j][i];
            p[j][i] = temp;
        }
    }
}