Question

我将一大块内存传递给我的子程序。在子程序中，我将此内存的一部分分配给内部1D数组指针。

  public class TestDate {

    public static void main(String[] args) {
    // TODO Auto-generated method stub

    String fromDate = "18-FEB-2018";
    String toDate = "20-FEB-2018";

    String requestDate = "19/02/2018";  
    System.out.println(checkBetween(requestDate,fromDate, toDate));
}

public static boolean checkBetween(String dateToCheck, String startDate, String endDate) {
    boolean res = false;
    SimpleDateFormat fmt1 = new SimpleDateFormat("dd-MMM-yyyy"); //22-05-2013
    SimpleDateFormat fmt2 = new SimpleDateFormat("dd/MM/yyyy"); //22-05-2013
    try {
     Date requestDate = fmt2.parse(dateToCheck);
     Date fromDate = fmt1.parse(startDate);
     Date toDate = fmt1.parse(endDate);
     res = requestDate.compareTo(fromDate) >= 0 && requestDate.compareTo(toDate) <=0;
    }catch(ParseException pex){
        pex.printStackTrace();
    }
    return res;
   }
 }

我如何指定第二个成员2D阵列？

Answer 1

struct中的声明float c[][SIZE_C2]声明了一个数组数组，这些数组在结构中内联存储。该声明不包含任何指向存储在别处的数组的指针。

如果您希望保留当前的结构签名，可以按以下方式填充c：

memcpy(&obj->c, mem_p, SIZE_C1 * SIZE_C2 * sizeof(float));

这会将mem_p中的数据复制到连续的数组c中，之后c不会引用来自mem的任何数据，就像a一样1}}和b，而是拥有自己的数据副本。

请记住，您的struct当前将c保存为“灵活的数组成员”，因为最外层的数组具有未指定的大小，这意味着您的结构必须通过malloc或类似的动态分配。必须给予额外的空间来保存数组元素：

OBJ *obj = malloc(sizeof *obj + SIZE_C1 * sizeof(float));

如果您只打算在obj中存储引用mem引用的内存而不存储单独副本的指针，那么c与a和{{ 1}}，您必须将结构中b的声明更改为以下内容：

这声明float (*c)[SIZE_C2];是“指向c元素数组的指针”（可能在一个连续的数组序列中），而不是“{{1}的数组数组元素“。

这可以在SIZE_C2函数中填充，如下所示：

SIZE_C2

如果您希望在init之后分配更多obj->c = (float (*)[SIZE_C2]) mem_p;字段，则可以继续递增float，而不是将其转换为指向数组的指针，因为C中的数组只是其元素类型的大小乘以其元素的数量：

使用这种方法，元素仍然可以作为mem_p访问，就像当前结构的签名一样。

由于指向数组的指针在C中使用有点棘手，并且要求内部数组具有固定大小，因此您可能会发现将/* sizeof(float [SIZE_C2]) == SIZE_C2 * sizeof(float) */ /* mem_p is a `float *` so goes up in steps of `sizeof(float)` */ mem_p += SIZE_C1 * SIZE_C2;存储为常规单obj->c[1][2]指针更合适并自己手动地解释元素，就好像它是一个二维数组，例如：

Answer 2

我一直在想这个问题，也许你整个事情都过于复杂。据我所知，你开始使用静态分配的结构：

typedef struct
{
    float a[SIZE_A];
    float b[SIZE_B];
    float c[SIZE_C1][SIZE_C2];
} OBJ;

现在您希望动态分配内存。因此，您分配一块大小为sizeof(float) * (SIZE_A + SIZE_B + SIZE_C1 * SIZE_C2)的内存，并将结构中的指针设置为该内存。

但请注意那块内存是如何与原始结构的大小完全相同的？那么为什么不动态分配原始结构而不是将结构成员更改为指针？

void init( OBJ** obj, void* mem )
{
    *obj = (Obj*)mem;
    memset(mem, 0, sizeof(OBJ));
}

void cleanup( OBJ** obj) {
    free(*obj);
    *obj = NULL;
}

你甚至可以将malloc（）移动到init（）函数中，使其更容易使用，就像我在cleanup（）中调用free（）一样。

Answer 3

你做不到。在你的struct float c[][SIZE_C2];中是一个二维浮点数组，它存在于struct中。它不是指向您可以指向您分配的内存的指针。你必须使c指向一个二维数组，如下所示：

#define SIZE_A 4
#define SIZE_B 8
#define SIZE_C1 12
#define SIZE_C2 16

struct Float2D {
    float c[0][SIZE_C2];
};

typedef struct
{
    // float a[SIZE_A];
    // float b[SIZE_B];
    // float c[SIZE_C1][SIZE_C2];

    float* a;
    float* b;
    struct Float2D *c;
} OBJ;


void init( OBJ* obj, void* mem )
{
    float* mem_p = (float*)mem; 

    obj->a = mem_p; 
    mem_p += SIZE_A;

    obj->b = mem_p; 
    mem_p += SIZE_B;

    obj->c = (struct Float2D*)mem_p;
}

注意：float c[0][SIZE_C2];中的0是必需的，因为您不能只有flex数组的结构。这可能是gcc编译器扩展。也许你可以弄清楚如何在没有额外结构的情况下指定类型。

将2D数组指定为void *

3 个答案: