Question

我正在创建一个动态分配的链表，其中每个项都有一个数据元素。这些元素中的大多数是固定大小的char数组，但是一些可以具有不同的长度，例如。只有1或2个字符 - 或1000 +。

如果我在数据元素中使用带有静态和动态字符数组的联合 - 它总是会占用：

静态大小的大小，或者malloc大小的malloced大小？
静态的大小+如果malloc大小的malloced一个？
指向malloced指针的指针大小或静态指针的大小？
...（依此类推）

没有列表的简化示例。这不是我用数据填充的方式， - 仅作为结构联合的一个例子。

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

enum meta_type {LIST, STRING};

struct meta {
    union {
        char clist[128];
        char *cstr;
    } val;
    enum meta_type type;
};

int init_meta(struct meta *meta, enum meta_type type, int size, char *data)
{
    if (type == STRING) {
        if ((meta->val.cstr = malloc(size + 1)) == NULL) {
            puts("Out of memeory");
            return 1;
        }
        sprintf(meta->val.cstr, "%s", data);
    } else {
        memset(meta->val.clist, 0, 128);
        meta->val.clist[0] = data[0];
        meta->val.clist[1] = data[1];
        meta->val.clist[2] = data[2];
    }

    meta->type = type;

    return 0;
}

void free_meta(struct meta *meta)
{
    if (meta->type == STRING)
        free(meta->val.cstr);
}

int main(int argc, char *argv[])
{
    struct meta meta;
    char list[] = {'a', '3', 'f'};

    if (argc > 1) {
        if(init_meta(&meta, STRING, strlen(argv[1]), argv[1]))
            return 1;
    } else {
        init_meta(&meta, LIST, 0, list);
    }

    fprintf(stdout,
        "meta[%d]: %s\n",
        meta.type,
        meta.type == LIST ? meta.val.clist : meta.val.cstr
    );

    free_meta(&meta);

    return 0;
}

@Floris：我测试过的一种愚蠢的方式：

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

enum meta_type {LIST, STRING};

#define SIZE_CLIST  128

struct meta {
    enum meta_type type;
    union {
        char clist[SIZE_CLIST];
        char *cstr;
    } val;
};

int init_meta(struct meta **meta, enum meta_type type, int size, char *data)
{
    if (type == STRING) {
        if (offsetof(struct meta, val) == 0) {
            puts("Ups.");
            return 2;
        }
        *meta = malloc(sizeof(struct meta) -
                SIZE_CLIST +
                sizeof(char *)
            );
        (*meta)->val.cstr = malloc(size + 1);
        if ((*meta)->val.cstr == NULL) {
            puts("Out of memeory");
            return 1;
        }
        sprintf((*meta)->val.cstr, "%s", data);
        puts((*meta)->val.cstr);
    } else {
        *meta = calloc(1, sizeof(struct meta));
        (*meta)->val.clist[0] = data[0];
        (*meta)->val.clist[1] = data[1];
        (*meta)->val.clist[2] = data[2];
    }

    (*meta)->type = type;

    return 0;
}

void free_meta(struct meta *meta)
{
    if (meta->type == STRING)
        free(meta->val.cstr);
    free(meta);
}

int main(int argc, char *argv[])
{
    struct meta *meta = NULL;
    char list[] = {'a', '3', 'f'};

    if (argc > 1) {
        if(init_meta(&meta, STRING, strlen(argv[1]), argv[1]))
            return 1;
    } else {
        init_meta(&meta, LIST, 0, list);
    }

    fprintf(stdout,
        "meta[%d] %d: %s\n",
        meta->type,
        sizeof(*meta),
        meta->type == LIST ? meta->val.clist : meta->val.cstr
    );

    free_meta(meta);

    return 0;
}

Answer 1

联盟将为最大的成员分配空间。你有一个数组和一个指针，所以它会为数组分配空间。指针的大小是固定的，它指向的是什么并不重要。

当您使用malloc时，空间未在数据结构内部分配，它位于内存中的其他位置。您将该内存位置分配给指针。

具有union静态和动态char数组的struct

1 个答案: