c - 矩阵函数的直和

Question

该结构允许表示任意大小的矩阵，其中 M 是行数，N 是列数，data 是指向按行存储的 double 型 M*N 值的指针。

struct matrix {
    size_t M, N;
    double *data;
};


struct matrix *mat_directsum(const struct matrix *a, const struct matrix *b);

函数ma​​t_directsum接受两个指向数组的指针作为参数，并应返回在堆上动态分配的直接和。

示例:

A.M = 2
A.N = 3 
A.data = (1, 1, 2, 0, 1, -3)

直接求和函数示例

我只需要一些关于如何设置函数的技巧，只是为了看看其他人如何处理这种类型的数组，因为想到的唯一方法是具有许多循环的迭代方法，但是，这已经足够了又长又巧妙，我想知道是否有更简单的方法来解决它。谢谢

ps。(内存分配当然不是问题)

编辑我是这样解决的:

struct matrix *mat_directsum(const struct matrix *a, const struct matrix *b) {
    struct matrix *c = malloc(sizeof(struct matrix));
    c->M = a->M + b->M;
    c->N = a->N + b->N;
    int n = c->M * c->M;
    double *dati = calloc(n, sizeof(double));

    int t = 0;//index new array
    int y = 0;//index first mat
    int z = 0;//index second mat
    for (int i = 0; i < c->N; i++) {
        if (i < a->N) {//first mat
            for (int j = 0; j < c->M; j++) {
                if (j < a->M) {
                    dati[t] = a->data[y];
                    y++;
                }
                t++;
            }
        } else {//second mat
            for (int j = 0; j < c->M; j++) {
                if (j >= a->M) {
                    dati[t] = b->data[z];
                    z++;
                }
                t++;
            }
        }
    }
    c->data = dati;
    return c;
}

我不知道如何做到这一点，只有一个 for 循环

Answer 1

//macro which will point to an element indexed at [xe][ye]
#define ELEMENT(data,rows,columns,xe,ye) (data+((xe)*(columns)+(ye)))

struct matrix
{
    size_t M, N;
    double *data;
};


//won't mind changing the return type from "struct matrix*" to "struct matrix"
struct matrix mat_directsum(const struct matrix *a, const struct matrix *b)
{
    int x;
    struct matrix res;
    res.M = a->M + b->M;
    res.N = a->N + b->N;

    //using calloc will set the memory to zero i.e all the bytes will be set to zero.
    res.data = (double*)calloc(res.M * res.N, sizeof(double));
    if(res.data == NULL)
    {
            return res;
    }

    for(x = 0; x < a->M; ++x)
    {
            memcpy(ELEMENT(res.data, res.M, res.N, x, 0), ELEMENT(a->data, a->M, a->N, x, 0), a->N * sizeof(double));
    }
    for(x = 0; x < b->M; ++x)
    {
            //note the offset by [a->M][a->N] while accessing elements of res.
            memcpy(ELEMENT(res.data, res.M, res.N, x + a->M, a->N), ELEMENT(b->data, b->M, b->N, x, 0), b->N * sizeof(double));
    }

    return res;
}


struct matrix res = mat_directsum(&a, &b);
if(res.data != NULL)
{
    free(res.data);
}