分配数组不会增加结构大小

Question

我有一个包含int数组(int[])的结构，我动态地分配它。但是，当我检查size don()大小时，没有发现任何增加的(数组)大小。打印的结果显示在下面。

我做错了什么？

typedef struct
{
    int TE_I;
    int TV_I;
    int TV_J;
    int CrossPointTV;
    int EdgeOrder;
    int OtherNakedFaceEdge;
    bool Visited;
    int *CrossPointConnectedEdges[1]; // ptr to dynamic int[] array
} mesh_edge_index_info;

int main()
    int edges_cnt = 10;
    mesh_edge_index_info *p_edge = malloc(1 * sizeof(*p_edge));;

    printf("size of edge in bytes        : %d\n", sizeof(*p_edge));
    printf("size of edge.TE_I            : %d\n", sizeof(p_edge->TE_I));
    printf("size of edge.TV_I            : %d\n", sizeof(p_edge->TV_I));
    printf("size of edge.TV_J            : %d\n", sizeof(p_edge->TV_J));
    printf("size of edge.CrossPointTV    : %d\n", sizeof(p_edge->CrossPointTV));
    printf("size of edge.EdgeOrder       : %d\n", sizeof(p_edge->EdgeOrder));
    printf("size of edge.OtherNFceEdge   : %d\n", sizeof(p_edge->OtherNakedFaceEdge));
    printf("size of edge.Visited         : %d\n", sizeof(p_edge->Visited));
    printf("size of edge.CrossPtConnEdges: %d\n", sizeof(p_edge->CrossPointConnectedEdges));


    printf("\n   Address of edge                  = %u", &p_edge);
    printf("\n   Address of edge.TE_I             = %u", &p_edge->TE_I);
    printf("\n   Address of edge.TV_I             = %u", &p_edge->TV_I);
    printf("\n   Address of edge.TV_J             = %u", &p_edge->TV_J);
    printf("\n   Address of edge.CrossPointTV     = %u", &p_edge->CrossPointTV);
    printf("\n   Address of edge.EdgeOrder        = %u", &p_edge->EdgeOrder);
    printf("\n   Address of edge.OtherNFcEdge     = %u", &p_edge->OtherNakedFaceEdge);
    printf("\n   Address of edge.Visited          = %u", &p_edge->Visited);
    printf("\n   Address of edge.CrossPtConnEdges = %u", &p_edge->CrossPointConnectedEdges);
    printf("\n\n");
    printf("-- add int[10] --");
    printf("\n\n");

    p_edge->CrossPointConnectedEdges = malloc(edges_cnt * sizeof(*p_edge->CrossPointConnectedEdges));

    //int ConnectedEdges[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    for (int i = 0; i < edges_cnt; i++)
    {
        p_edge->CrossPointConnectedEdges[i] = i;
    }

    printf("size of edge in bytes        : %d\n", sizeof(*p_edge));
    printf("size of edge.CrossPtConnEdges: %d\n", sizeof(p_edge->CrossPointConnectedEdges));

    return 0;

打印结果 --最后两行应该(在我的预期中)增加到sizeof(int) * 10的大小，但我没有看到任何变化，所以我肯定做错了什么：

    ================================================    
    size of edge in bytes        : 40
    size of edge.TE_I            : 4
    size of edge.TV_I            : 4
    size of edge.TV_J            : 4
    size of edge.CrossPointTV    : 4
    size of edge.EdgeOrder       : 4
    size of edge.OtherNFceEdge   : 4
    size of edge.Visited         : 4
    size of edge.CrossPtConnEdges: 8
    
       Address of edge                  = 676329832
       Address of edge.TE_I             = 3576450480
       Address of edge.TV_I             = 3576450484
       Address of edge.TV_J             = 3576450488
       Address of edge.CrossPointTV     = 3576450492
       Address of edge.EdgeOrder        = 3576450496
       Address of edge.OtherNFcEdge     = 3576450500
       Address of edge.Visited          = 3576450504
       Address of edge.CrossPtConnEdges = 3576450512
    
    // Add int[10]
    
    size of edge in bytes        : 40   // <-- no increase !
    size of edge.CrossPtConnEdges: 8    // <-- no increase !
    ================================================

Answer 1

正如您声明的那样，record mesh_edge_index_info的字段mesh_edge_index_info不是指向数组的指针，而是指向整数的指针的一个元素数组。您想要的只是一个指向整数的指针：

int *CrossPointConnectedEdges;

C中的内存分配非常低，而且容易出错，因此更容易定义分配宏并使用它而不是malloc函数。而且，将数组的长度存储在记录中更有意义，这样就可以将它们放在一起。我会这样做：

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NEW_ARRAY(ptr, n) \
        { \
                (ptr) = malloc((size_t) (n) * sizeof (ptr)[0]); \
                if ((ptr) == NULL) { \
                        fprintf(stderr, "memory allocation failed: %s\n", strerror(errno)); \
                        exit(EXIT_FAILURE); \
                } \
        }

#define NEW(ptr) NEW_ARRAY(ptr, 1)

typedef struct {
    int TE_I;
    int TV_I;
    int TV_J;
    int CrossPointTV;
    int EdgeOrder;
    int OtherNakedFaceEdge;
    int Visited;
    int edgesCount;
    int *CrossPointConnectedEdges;
} mesh_edge_index_info;


int main(void)
{
    mesh_edge_index_info *p_edge;
    int i;

    NEW(p_edge);
    p_edge->edgesCount = 10;
    NEW_ARRAY(p_edge->CrossPointConnectedEdges, p_edge->edgesCount);
    for (i = 0; i < p_edge->edgesCount; i++) {
        p_edge->CrossPointConnectedEdges[i] = i;
    }

    /*...*/

    free(p_edge->CrossPointConnectedEdges);
    free(p_edge);
    return 0;
}

Answer 2

sizeof只为提供指针的大小，而不是分配内存的大小。顺便说一句，要获取这些信息，没有办法。你需要把它存储在结构中的某个地方。

int *CrossPointConnectedEdges[1]; // ptr to dynamic int[] array

它不是指向动态int[]数组的指针。它是int *指针的一个元素数组。

我会用另一种方式：

typedef struct
{
    int TE_I;
    int TV_I;
    int TV_J;
    int CrossPointTV;
    int EdgeOrder;
    int OtherNakedFaceEdge;
    bool Visited;
    size_t numberofEdges;
    int CrossPointConnectedEdges[];
} mesh_edge_index_info;


mesh_edge_index_info *allocate(mesh_edge_index_info *eis, size_t nEdges, bool zero)
{
    eis = realloc(eis, sizeof(*eis) + nEdges * sizeof(eis -> CrossPointConnectedEdges[0]));
    if(eis) 
    {
        if(zero) memset(eis, 0, sizeof(*eis) + nEdges * sizeof(eis -> CrossPointConnectedEdges[0]));
        eis -> numberofEdges = nEdges;
    }
    return eis;
}

int main(void)
{
    //allocate new with 100 edges and zero the struct.
    mesh_edge_index_info *eis = allocate(NULL, 100, true);

    //change the number (too 500) ofthe edges keeping the vsalues
    eis = allocate(eis, 500, false);
}