Question

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

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


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

函数 mat_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;
}

我不知道怎么做只有一个用于循环

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

Answer 2

除了错误n = c->M * c->M（由MM发现（Ms的巧合！））之外，您的解决方案在for循环中还有另一个错误：您混淆了行号和列号M和N-因为值按行存储，外部循环必须为for (int i = 0; i < c->M; i++)，内部循环必须为for (int j = 0; j < c->N; j++)，因此所有M和{{1}在这些循环中（也在N中）必须进行交换。除此之外，还缺少分配错误检查，您的解决方案很好。

我不知道该怎么做，只有一个循环

如果您想看到另一种方法，请使用辅助函数将矩阵插入求和矩阵：

if

矩阵函数的直接和

2 个答案: