Question

我想创建一个矩阵结构，其行不均匀，如下所示：

[0] [0] 
[0] [0] [0] 
[0] [0] [0] [0] 
[0] [0] [0] [0] [0] 
[0] [0] [0] [0]

因此我想存储它的列长度以及每行的宽度。我的实现是这样的：

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

typedef struct {
    size_t size;
    int *data;
} dyn_row;

typedef struct {
    size_t size;
    dyn_row *row;
} dyn_matrix;

int main(void) {

    int i, j;
    dyn_matrix matrix;

    srand(time(NULL));
    // Allocate
    matrix.size = 5;
    matrix.row = malloc(matrix.size * sizeof(dyn_row));
    for (i=0; i<matrix.size; i++) {
        matrix.row[i].size = rand()%(i+1)+2;
        matrix.row[i].data = malloc((matrix.row[i].size) * sizeof(int));
    }
    // Initialize
    for (i=0; i<matrix.size; i++) {
        for (j=0; j<matrix.row[i].size; j++) {
            matrix.row[i].data[j] = 0;
        }
    }
    // Print values & free
    for (i=0; i<matrix.size; i++) {
        for (j=0; j<matrix.row[i].size; j++) {
            printf("[%d] ", matrix.row[i].data[j]);
        }
        printf("\n");
        free(matrix.row[i].data);
    }
    free(matrix.row);

    return 0;
}

这是一个很好的解决方案吗？解决这个问题的最佳实现是什么？此外，这是一个很好的做法，而不是＆＃34; int * data＆＃34;写＆＃34; void * data＆＃34;所以矩阵可以包含任何类型的数据吗？

Answer 1

如果你知道你想要实现的目标被称为＆＃34;锯齿状阵列＆＃34;你可能会发现更多的例子;虽然您也会发现其他语言更好地支持这种数据结构。

分配数据是微不足道的部分，但是你可以很好地定义单独的函数来分配和访问数组以安全地包装这些操作（访问边界检查，内存管理等）。例如，您可以定义：

typedef dyn_matrix* tJaggedArray ;

// Create n rows of initially zero length
tJaggedArray jaggedCreate( int rows ) ; 

// Set the length and allocate a row in array
tJaggedArray jaggedAllocRow( tJaggedArray array, int row, int length ) ;

// Get an array element, return true if element exists, else false
bool jaggedGet( tJaggedArray array, int row, int col, int* value ) ;

// Set an array element, return true if element exists, else false
bool jaggedSet( tJaggedArray array, int row, int col, int value ) ;

// Clean up array resources
void jaggedDestroy( tJaggedArray array ) ;

在C ++中你当然可以将它包装在一个类中，这样你就不必将数组指针传递给每个函数，你可以使用模板来支持不同类型的数组，并且运算符重载使得数组访问看起来像像内置的数组访问。在C＃中，边界检查是内置于语言中的。

保持不均匀动态矩阵的结构？

1 个答案: