Question

我在C中写了一个n×n矩阵乘法程序，其中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在此基础上引入了各种有趣的优化可能性，所有这些在我所知的任何编译器中几乎都不能依赖：

有了这些，这样的事情应该是可能的：

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，并且在运行时从调用代码指示大小。此外，所有数组都是可缓存的，因为它们彼此不alias。

人们只能梦想C继续前进，C99仍未得到完全支持，许多other improvements尚未成为主流。

Answer 2

你必须在乘法方法

中传递两个矩阵的第一个元素的地址

实际上，事实是数组的元素排列像队列一个接一个元素。所以，如果您知道第一个元素的地址，那么您只需增加索引号，就可以轻松获得该数组的所有成员。

检查this

它可能对你有帮助

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

这是将动态分配的数组传递给函数的简单方法。

#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);

将动态2D数组传递给函数

4 个答案: