Question

我的问题难以描述，我有两张分别包含大量数字的表格;对于一个表，我通过索引

搜索格式

table1   index format  
        +------+----+                        
        |0~19  |  0 |
        |      |    |
        +------+----+
        |20~29 |  1 |
        |      |    |
        +------+----+
        |30~39 |  2 |
        |      |    |
        +------+----+

table2  index  resource(f,t0,t1,t2)  
                  0           1        2         3 (configure type)
        +----+-----------+---------+---------+                      
        |0   | (0,1,0,2) |(0,1,0,1)|(0,1,0,0)|
        +----+-----------+---------+---------+
        |1   | (0,2,0,2) |(0,2,0,1)|(0,2,0,0)|
        +----+-----------+---------+---------+
        |--  | (0,0,1,2) |(0,0,1,1)|(1,0,0,0)|
        +----+-----------+---------+---------+
        |19  | (0,0,0,0) |(0,0,0,0)|(0,0,1,1)|
        +----+-----------+---------+---------+---------+
        |--  | (0,0,0,2) |(0,0,0,1)|(0,0,1,0)|(0,2,1,0)|
        +----+-----------+---------+---------+---------+
        |29  | (0,1,0,2) |(0,1,0,1)|(0,1,0,1)|(0,1,0,1)|
        +----+-----------+---------+---------+---------+

希望以下代码段可以让我理解，

typedef struct my_struct {
    int f;
    int t0;
    int t1;
    int t2;
} my_struct;

// for index 0 ~ 19, the following is code snippet
    my_struct format0[2][3] = {
        {{0, 1, 0, 2}, {0, 1, 0, 1},{0, 1, 0, 0}}, // index 0
        {{0, 2, 0, 2}, {0, 2, 0, 1},{0, 2, 0, 0}}  // index 1
    };

// for index 20 ~ 29, the following is code snippet    
my_struct format1[1][4] = {
    {{0,0,0,2},{0,0,0,1},{0,0,1,0},{0,2,1,0}} // index 20
};

我有多个2d数组，其中包含按format分组的资源，每个数据都有不同的format维度，由index划分，由configure type排列，如0,1， 2..6，所以我想把它们放到另一个1d数组中，以便通过索引轻松查找，最后得到资源，但我不知道如何。

我尝试了以下但失败了：

my_struct* group[] = {
    format0,
    format1
};

然后使用group[0]，我可以获得format0，但我发现它忘记了我需要知道的[1][2]，所以我想知道有一些解决方案可以帮助我做到这一点吗？

Answer 1

假设每个数组维度都包含两个数组d1（行数）和d2（列数），您可以这样做：

struct foo {
    my_struct** arr;
    int dim1;
            int dim2;
};

foo group[dimension] = {
    {format0,d1[0],d2[0]},
    {format1,d1[1],d2[1]},
};

因此，您可以保持数组的维度接近，并可以像这样使用它们，例如：

for (int i = 0;i<dimension;i++)
{
    for(int j = 0;j<group[i].dim1;j++)
    {
        for (int k=0;k<group[i].dim2;k++)
        {
            group[i].arr[j][k]; // do something with it!
        }
    }
}

否则，如果您没有d1，d2和dimension中的维度，则在定义数组后不可能知道它们，因此您不会能够搜索（正如你所说的那样）。

Answer 2

你的结构似乎没有包含太多的实际数组/矩阵。

我会用这样的东西：

typedef struct
{
  size_t width, height;
  int    *data;
} Matrix2D;

然后定义一个初始化实例的函数：

int matrix2d_new(Matrix2D *out, size_t width, size_t height)
{
  if(out == NULL || width == 0 || height == 0)
    return 0;
  if((out->data = malloc(width * height * sizeof *out->data)) != NULL)
  {
    out->width = width;
    out->height = height;
    memset(out->data, 0, width * height * sizeof *out->data);
  }
  return out != NULL;
}

然后你可以简单地构建一个数组：

Matrix2D matrices[3];
matrix2d_new(&matrices[0], 12, 34);
matrix2d_new(&matrices[1], 40, 50);
matrix2d_new(&matrices[2], 20, 50);

忽略错误检查，但在处理动态内存时当然必须考虑错误检查。

Answer 3

通过将group视为指针数组，您将失去以2D数组的形式访问指针的能力。

一种选择是仅使用1D阵列：

my_struct format00[3] = {{1,2,3}, {4,5,6}, {7,8,9}};
my_struct format01[3] = {{10,20,30}, {40,50,60}, {70,80,90}};

my_struct *format0[2] = {format00, format01};
my_struct *format1[2] = {format10, format11};

my_struct **group[] = {format0, format1};

my_struct a = group[0][0][1];  // {4,5,6}

当然，这对初始化来说不太方便。

Answer 4

如果您实际上使用的是C ++而不是C，那么您可以使用更加以C ++为中心的解决方案，std::vector和C ++ 11初始化列表：

#include <iostream>
#include <vector>

using std::cout;
using std::vector;

typedef struct my_struct {
    int i;
    int j;
    int k;
} my_struct;

typedef vector<vector<my_struct>> Matrix;

Matrix format0 {
    {{0, 1, 2}, {1, 2, 3}}
};

Matrix format1 {
    {{0, 1, 2}, {1, 2, 3}, {2, 3, 4}},
    {{3, 4, 5}, {4, 5, 6}, {5, 6, 7}}
};

vector<Matrix*> groups { &format0, &format1 };

int main(int argc, char** argv) {
    for (auto i = groups.begin(); i != groups.end(); ++i)
        cout << (**i).size() << 'x' << (**i)[0].size() << '\n';
}

但这仍然不寻常，我不确定你真正试图解决的问题。如果您需要的是一个合适的Matrix类，那么您应该编写一个，这样您就可以停止处理原始数组并专注于您真正想要做的事情。

2d数组的数组

4 个答案: