умножение матриц с использованием указателей в c

Question

#include<stdio.h>

int mul(int *a[3][3], int *b[3][3]);

int i,j,k,*c[3][3],*a[3][3],*b[3][3];

int main()
{
    printf("enter the elements of 1st 3*3 matrix:A");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            scanf("%d",&a[i][j]);
        }
    }
    printf("enter the elements of 1st 3*3 matrix:B");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            scanf("%d",&b[i][j]);
        }
    }
    mul(a,b);
    printf("result=");
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            printf("\t%d\t",*c[i][j]);
        }
        printf("\n");
    }
}

int mul(int *a[3][3], int *b[3][3])
{
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            *c[i][j]=0;
            for(k=0;k<3;k++)
            {
                c[i][j] = *a[i][k] * *b[k][j] + *c[i][j];
            }
        }
    }
}

Я пытаюсь сделать матричное умножение, используя указатели, но я не получаю никакого результата.

Я искал в Google, но не могу понять ни одного из них.

и любой из них сильно отличался от моего.

, пожалуйста, помогите мне.

Answer 1

Здесь происходит две основные вещи:

1. Когда вы объявляете указатель, например, int* x, это создает глобальную переменную для хранения местоположения массива целых, но не создает фактический массив самих целых. Если вы просто сделаете это объявление, а затем выполните *x = 0;, вы получите ошибку (вероятно). На самом деле создание массива требует выделения памяти с помощью вызова malloc. Эта статья описывает основы.
2. Типы многомерных массивов немного забавны в C, когда вы используете указатели. Обычно я пишу такой код, представляя матрицу в виде типа int**. Значение x типа int** является указателем на указатель на значение. Вы можете написать x[2][3], чтобы получить значение 2-й строки / 3-го столбца матрицы, и аналогичным образом назначить, используя x[1][0] = 5 (например).

Поэтому я бы поменял в начале объявления так:

int mul(int** a, int** b);
int i,j,k,**c,**a,**b;

Тогда я бы написал функцию для выделения матрицы 3x3.

int** alloc_matrix(int rows, int cols)
  int** matrix = (int**)malloc(sizeof(int*)*rows);
  for(int i = 0; i < rows; i++) {
    matrix[i] = (int*)malloc(sizeof(int)*cols);
  }
  return matrix;
}

Тогда ваша основная функция выглядит как

int main() {
  a = alloc_matrix(3,3);
  b = alloc_matrix(3,3);
  c = alloc_matrix(3,3);
  ...

Вам также нужно удалить оператор разыменования * в нескольких местах, чтобы эта работа работала. Для тебя это домашнее задание: -)

Есть и другие способы сделать это, но это наиболее интуитивное решение, использующее указатели для меня. Вы также можете сделать это без указателей, просто статически выделяя a, b и c как массивы 3x3.

Answer 2

При умножении матриц вручную на указатели вы можете представить их как один array[] вместо вектора array[][].

Таким образом, указатели легче перемещать.Рассмотрим эту реализацию :

void matmul(double *dest, const double *lhs, const double *rhs,
            size_t rows, size_t mid, size_t cols) {
    memset(dest, 0, rows * cols * sizeof(double));

    for (size_t i = 0; i < rows; ++i) {
        const double *rhs_row = rhs;
        for (size_t j = 0; j < mid; ++j) {
            for (size_t k = 0; k < cols; ++k) {
                dest[k] += lhs[j] * rhs_row[k];
            }
            rhs_row += cols;
        }
        dest += cols;
        lhs += mid;
    }
}