想要编写一个可以调用的函数，能实现矩阵的乘法，矩阵的维数不固定，但是可以通过传参传入函数中，传入的参数中包括一个存放结果的矩阵，我使用了宏定义函数编写矩阵乘法，如果不想使用宏定义函数的话，该怎么写？遇到的问题是在定义函数参数时，矩阵的维数不能确定，不知道要怎么处理，动态内存分配也不太清楚应该在何处使用，请前辈指点。
这是我写的宏定义函数实现的矩阵乘法

#include <stdio.h>
#define MATRIX_PRINT(mtx)         matrix_print( sizeof(mtx)/sizeof(*(mtx)), sizeof(*(mtx))/sizeof(**(mtx)), (mtx) )
#define MATRIX_MUT(a,b,c)         matrix_mut(sizeof(a)/sizeof(*(a)),sizeof(*(a))/sizeof(**(a)),sizeof(*(b))/sizeof(**(b)),(a),(b),(c))

void matrix_print( size_t row, size_t col, float mtx[row][col] )
{
    size_t r=0,c=0;
    for(  r=0; r<row; r++)
    {
        for(  c=0; c<col; c++ )
        {
           printf( "%f ", mtx[r][c]);
        }
    }
}

void matrix_mut(size_t row,size_t med,size_t col,float a[row][med],float b[med][col],float c[row][col])
{
  size_t i,j,l;
  for(i=0;i<row;i++)
  {
      for(j=0;j<col;j++)
      {
          float sum=0;
          for(l=0;l<med;l++)
          {
              sum=sum+a[i][l]*b[l][j];
          }
          c[i][j]=sum;
      }
  }
}
int main( void )
{
    float a[2][3] = { {1,2,3}, {1,5,2} };
    float b[3][2]={1,2,2,1,3,1};
    float d[2][2];
    MATRIX_MUT(a,b,d);
    MATRIX_PRINT( d );
    return 0;
}

矩阵不都是二维的吗？你真的是维数不固定，还是每维的长度不固定？

当然，不管是哪种，你都可以用一维数组去存放。
比如一个3维矩阵，每维长度分别是 6，7，8。
用多维数组那么定义为 type mtx1[6][7][8]
用一维数组那么定义为 type mtx2[6*7*8]
mtx1[a][b][c] 其实就是 mtx2[ a*7*8 + b*8 + c ]

二维矩阵：
矩阵Ａ元素数确定，行数确定，则列数=元素数/行数；
矩阵Ｂ元素数确定，行数=矩阵Ａ列数，列数=元素数/行数；
结果矩阵=动态分配内存矩阵A行数*矩阵Ｂ列数

是这个？

[此贴子已经被作者于2020-6-20 23:48编辑过]

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

void matrix_print(int row, int col, float** mtx);
void matrix_mut(int row_a, int col_a, int col_b, float** a, float** b, float** c);

void matrix_print(int row, int col, float** mtx)
{
    int r = 0, c = 0;
    for (r = 0; r < row; r++)
    {
        for (c = 0; c < col; c++)
        {
            printf("%g ", *(*(mtx + r) + c));
        }
        printf("\n");
    }
}

void matrix_mut(int row_a, int col_a, int col_b, float** a, float** b, float** c)
{
    int i, j, k;
    for (i = 0; i < row_a; i++)
    {
        for (j = 0; j < col_b; j++)
        {
            float sum = 0;
            for (k = 0; k < col_a; k++)
            {
                sum += *(*(a + i) + k) * *(*(b + k) + j);
            }
            *(*(c + i) + j) = sum;
        }
    }
}
int main(void)
{
    int i, j;
    float** a, ** b, ** c;
    int row_a, col_a, row_b, col_b;

    printf("请输入矩阵A的行数,列数:\n");
    scanf("%d,%d", &row_a, &col_a);
    a = (float**)malloc(row_a * sizeof(float*));
    for (i = 0; i < row_a; i++)
        a[i] = (float*)malloc(col_a * sizeof(float));
    printf("请输入矩阵A:\n");
    for (i = 0; i < row_a; i++)
        for (j = 0; j < col_a; j++)
            scanf("%f", &a[i][j]);

    row_b = col_a;
    printf("请输入矩阵B的列数:\n");
    scanf("%d", &col_b);
    b = (float**)malloc(row_b * sizeof(float*));
    for (i = 0; i < row_b; i++)
        b[i] = (float*)malloc(col_b * sizeof(float));
    printf("请输入矩阵B:\n");
    for (i = 0; i < row_b; i++)
        for (j = 0; j < col_b; j++)
            scanf("%f", &b[i][j]);

    c = (float**)calloc(row_a, sizeof(float*));
    for (i = 0; i < row_a; i++)
        c[i] = (float*)calloc(col_b, sizeof(float));


    //    float a[2][3] = {{1,2,3}, {1,5,2}};
    //    float b[3][2]= {{1,2},{2,1},{3,1}};
    //    float d[2][2];

    matrix_mut(row_a, col_a, col_b, a, b, c);
    matrix_print(row_a, col_b, c);

    for (i = 0; i < row_a; i++)
        free(*(a + i));
    free(a);

    for (i = 0; i < row_b; i++)
        free(*(b + i));
    free(b);

    for (i = 0; i < row_a; i++)
        free(*(c + i));
    free(c);

    return 0;
}

是的，我描述错了，是二维矩阵的行数和列数不确定

我想表达的就是，函数能够计算矩阵A和矩阵B的乘法，保存在C矩阵中，矩阵A的列数和矩阵B的行数相同，矩阵A和矩阵B在函数中是不确定的，只有在主函数中给出了才能确定两个矩阵的行数和列数，我想表达的就是这个意思

“遇到的问题是在定义函数参数时，矩阵的维数不能确定，不知道要怎么处理”　＆　“矩阵A的列数和矩阵B的行数相同，矩阵A和矩阵B在函数中是不确定的”

矩阵Ａ和矩阵Ｂ到底确定吗？如果确定，只是维数不确定，最笨蛋的方法就全域搜索一下。比如你给的题目矩阵Ａ6个元素，矩阵Ｂ6个元素，则可行解为1*6 & 6*1、2*3 & 3*2、3*2 & 2*3、6*1 & 1*6。

在主函数中已经知道矩阵的行数和列数还有元素值，不需要用键盘输入，在主函数中计算多个矩阵的相乘，比如说计算4*6的矩阵和6*6的矩阵的乘法，还要计算2*3和3*4 4*4和4*4的矩阵的乘法，想把矩阵乘法的过程写成一个函数，10阶以内矩阵乘法都能计算，可以在主函数中直接调用，不在主函数中写多个矩阵乘法的过程；

听不懂，你把 main 函数的代码贴出来