将结构传递给函数并将值存储在结构的元素中

Question

我想将结构传递给函数并将值存储在结构的元素中。这是我的代码。

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

typedef struct {
    uint32_t len;
    uint16_t *arr;
} seq;

void write_seq(seq *q, int val)
{
    // How to implement this function?

    uint16_t *tmp;
    tmp = (uint16_t *)malloc(sizeof(uint16_t));
    *tmp = val;

    *(q->arr + q->len) = *tmp;
    q->len += 1;

}

int main(int argc, char *argv[])
{
    seq q;
    q.len = 0;
    q.arr = NULL;
    int i;
    for (i = 0; i < 10; i++) {
        write_seq(&q, i);
    }

    printf("length is %d\n", q.len);
    for (i = 0; i < q.len; i++) {
        printf("%d\n", *(q.arr+i));

    }

    return 0;
}

我想将 0 到 9 写入 q.arr 指向的内存块。
我不想在 main() 中使用 malloc，因为在调用 write_seq 之前我不知道需要多少字节。每次调用 write_seq 时，我都想定位新内存。输出应该是这样的。

length is 10
0
1
2
3
4
5
6
7
8
9

我的 write_seq() 实现会导致核心转储。我不知道如何解决它。谢谢。

Answer 1

你需要使用realloc()，而不是malloc()，像这样：

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

typedef struct {
    int len;
    int *arr;
} seq;

void write_seq(seq *q)
{
    q->arr = realloc (q->arr, (q->len + 1) *  sizeof(int));
    q->arr[q->len] = q->len;
    q->len++;
}

int main(void)
{
    seq q;
    q.len = 0;
    q.arr = NULL;

    for(int i = 0; i < 10; ++i)
        write_seq(&q);


    printf("length is %d\n", q.len);
    for (int i = 0; i < q.len; i++) {
        printf("%d\n", q.arr[i]);
    }

    free(q.arr);

    return 0;
}

输出：

length is 10
0
1
2
3
4
5
6
7
8
9

Answer 2

当您事先不知道该数组的大小时，要向该数组添加成员，您需要使用realloc() 来按需增加大小。但是，对于数组大小的每一次更改，这样做效率低下，因此更通常的做法是在缓冲区。

因此，您需要存储缓冲区的当前 容量 以及相对于 当前 使用量的偏移量。

这也意味着会有一定数量的内存浪费，但这是你必须做出的权衡。

我的方法看起来像这样，抽象您可能希望在 seq 上执行的操作。

typedef struct {
    size_t    capacity;
    size_t    offset;
    uint16_t *arr;
} seq;

static const size_t SEQ_INITIAL = 8;
static const size_t SEQ_INCREMENT = 8;

int seq_init(seq *seq) {
    assert(seq != NULL);         /* catch null seq */
    assert(seq->arr == NULL);    /* error to call on already init'd seq */
    seq->capacity = SEQ_INITIAL;
    seq->offset = 0;
    seq->arr = malloc(seq->capacity * sizeof(seq->arr[0]));
    return seq->arr == NULL ? -1 : 0;
}

static int seq_grow(seq *seq) {  /* private implementation detail */
    size_t new_capacity = seq->capacity + SEQ_INCREMENT;
    void *p = realloc(seq->arr, new_capacity * sizeof(seq->arr[0]));
    if (p == NULL) {             /* realloc failed, seq unmodified */
        return -1;
    }
    seq->arr = p;
    seq->capacity = new_capacity;
    return 0;
}

int seq_write(seq *seq, uint16_t value) {
    assert(seq != NULL);         /* catch null seq */ 
    if ((seq->offset == seq->capacity) && seq_grow(seq) < 0) {
        return -1;               /* write failed */
    }
    assert(seq->arr != NULL);    /* catch bad seq */
    assert(seq->offset < seq->capacity); /* ensure seq really has room */
    seq->arr[seq->offset++] = value;
    return 0;
}

void seq_free(seq *seq) {
    if (seq != NULL) {
        free(seq->arr);
        seq->arr = NULL;
    }
}