передача динамических 2D-массивов в функцию

Question

Я пишу программу умножения матрицы тревожности на C, где a [] [] и b [] [] - входные данные, а x [] [] - выходные данные.a, b и x являются malloc'd, но я не уверен, как правильно передать указатели на функцию умножения.ниже приведено описание того, что я пытаюсь сделать

    void multiplication(float a, float b, float x, int n);

    void main() {

        float **a, **b, **x;
        int n;          // size of arrays (n x n)

        multiplication(a, b, x, n);
    }

   void multiplication(float a, float b, float x, int n) {

      // function

   }

Answer 1

Вы хотите void multiplication(float *a, float *b, float *x, int n);.Обратите внимание, что обычно вы должны использовать size_t для индексов и размеров массивов и double в качестве предпочитаемого типа с плавающей запятой, если у вас нет особых причин использовать float.

Каждый из a, b и x указывают на смежные значения с плавающей точкой, вы можете захотеть разыменовать их, используя a[n * x + y].

C99 предоставляет множество интересных возможностей оптимизации, которые вы в значительной степени не можетеполагаться на любой известный мне компилятор:

• Массивы переменной длины в GCC
• Массивы в XL C / C ++ V7.0 (для AIX)

С этим должно быть возможно что-то подобное:

void multiplication(size_t len; // <- semicolon not a mistake
    double a[len][restrict const len],
    double b[len][restrict const len],
    double c[len][restrict const len]);

Эта педантичная конструкция будет указывать компилятору, что длина массивов одинакова, они 2D, а размеры указаны из кода вызова во время выполнения.Кроме того, все массивы кэшируются, поскольку они не псевдоним друг друга.

Можно только мечтать, что C продолжает развиваться, C99 все еще не полностью поддерживается, и многие другие улучшения не стали мейнстримом.

Answer 2

Вот хороший простой способ передать динамически распределенные массивы в функцию.

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

void Function(int ***Array);

int main()
{
    int i, j, k, n=10;

    //Declare array, and allocate memory using malloc. ( Dimensions will be 10 x 10 x 10)
    int ***Array=(int***)malloc(n*sizeof(int**));
    for (i=0; i<n; i++)
    {
        Array[i]=(int**)malloc(n*sizeof(int*));
        for (j=0; j<n; j++)
        {
            Array[i][j]=(int*)malloc(n*sizeof(int));
        }
    }

    //Initialize array in a way that allows us to check it easily (i*j+k).
    for (i=0; i<n; i++)
    {
        for (j=0; j<n; j++)
        {
            for (k=0; k<n; k++)
            {
                Array[i][j][k]=i*j+k;
            }
        }
    }
    //Check array is initialized correctly.
    printf("%d\n", Array[4][5][6]);

    //Pass array to Function.
    Function(Array);

    //Check that Function has correctly changed the element.
    printf("%d\n", Array[4][5][6]);

    return 0;
}

void Function(int ***Array)
{
    //Check that Function can access values correctly.
    printf("%d\n", Array[4][5][6]);
    //Change an element.
    Array[4][5][6]=1000;
}

Я знаю, что это не относится к умножению вашей матрицы, но оно должно продемонстрировать, как передать массив в функцию. Вполне вероятно, что вашей функции нужно будет знать размеры массива, поэтому передайте их также ... void Function(int ***Array, int n) и вызовите функцию как Function(Array, n);

Answer 3

Ну, вы должны понимать указатели для того, чтобы делать такие вещи на C. Вот простой код:

int n = 10;

float * multiply ( float *a, float *b ) {
    float *ans;
    int i, j, k;
    ans = malloc(sizeof(float)*n*n);

    for (i=0; i<n; ++i)
        for (j=0; j<n; ++j) {
            ans[i*n+j] = 0.0;
            for (k=0; k<n; ++k)
                ans[i*n+j] += a[i*n+k] * b[k*n+j];
        }

    return ans;
}

int main() {
    float *a, *b, *ans;

    a = malloc(sizeof(float)*n*n);
    input(&a);
    b = malloc(sizeof(float)*n*n);
    input(&b);

    ans = multiply(a,b);
    output(ans);

    return 0;
}

Если у вас возникли проблемы с пониманием кода, попробуйте освежить свои навыки работы с указателями.И вы всегда можете спросить нас.

Answer 4

Вы должны передать адрес первого элемента обеих матриц в методе умножения

на самом деле дело в том, что элементы массива расположены так, как очередь означает один элемент за другим. так что если вы знаете адрес первого элемента, вы просто увеличиваете порядковый номер и легко получаете всех членов этого массива.

чек это

это может помочь вам