0

在 C 中，我希望有一个结构，它会不时接收特定类型的新数据（假设是一个告诉当前温度的浮点值）。现在的问题是我不知道随着时间的推移我会得到多少这样的数据（软件保持打开的时间越长，我收到的数据就越多），我也不想限制我的结构的数据量会接受。

我怎样才能在 C 中做到这一点？

为了建立关系，这相当于在 C++ 中，声明一个带有 Vector 或 List 的结构，并在每次出现新数据时连续调用 vector::push_back(T)，能够做到这一点，直到 PC 中的所有内存都用完消耗。现在，AFAIK，C 中没有可用的容器，例如向量或列表，那么该怎么做呢？

谢谢，

莫默吉尔

4

3 回答 3

2

这是我刚才写的一个例子：

主程序

#include "queue.h"

int main() {
    vector_handle v = vector_create();

    int i;
    for (i=0; i<100; ++i)
        vector_push(v, 0.5 * i);

    for (i=0; i<vector_size(v); ++i)
        printf("data: %f\n", vector_data(v)[i]);

    vector_destroy(v);
}

队列.h

#pragma once
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct vector * vector_handle;

vector_handle vector_create();
void vector_destroy(vector_handle vector);
void vector_realloc(vector_handle vector);
size_t vector_size(vector_handle vector);
float * vector_data(vector_handle vector);
void vector_push(vector_handle vector, float data);
float vector_pop(vector_handle vector);

队列.c

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

#include "queue.h"

struct vector {
    float *data;
    size_t size;
    size_t capacity;
};

struct vector * vector_create() {
    struct vector *object = malloc(sizeof(struct vector));
    object->size = 0;
    object->capacity = 16;
    object->data = malloc(sizeof(float) * object->capacity);
    return object;
}

void vector_destroy(struct vector *object) {
    free(object->data);
    free(object);
}

void vector_realloc(struct vector *object) {
    object->capacity *= 2;
    object->data = realloc(object->data, sizeof(float) * object->capacity);
    assert(object->data);
}

size_t vector_size(struct vector *object) {
    return object->size;
}

float * vector_data(struct vector *object) {
    return object->data;
}

void vector_push(struct vector *object, float data) {
    if (object->size == object->capacity)
        vector_realloc(object);
    object->data[object->size] = data;
    object->size++;
}

float vector_pop(struct vector *object) {
    return object->data[object->size--];
}
于 2014-04-14T17:15:54.767 回答
2

您可以实现自己的动态数组。像这样的东西：

typedef struct {
  int *array;
  size_t used;
  size_t size;
} Array;

int initArray(Array *a, size_t initialSize) {
  a->array = (int *)malloc(initialSize * sizeof(int));
  if(!a->array)
    return -1;
  a->used = 0;
  a->size = initialSize;
  return 0;
}

int insertArray(Array *a, int element) {
  if (a->used == a->size) {
    a->size *= 2;
    int *newMemory = (int *)realloc(a->array, a->size * sizeof(int));
    if(!newMemory)
      return -1;
    a->array = newMemory;
  }
  a->array[a->used ++] = element;
  return 0;
}

void freeArray(Array *a) {
  free(a->array);
  a->array = NULL;
  a->used = a->size = 0;
}

有关详细信息，请参阅此帖子。

于 2014-04-14T17:14:16.937 回答
1

这是堆栈的可能实现。您可以使用自己的堆栈实现并实现 push、pop 和 number_of_element() 

 typedef struct node {
        int value;
        struct node *next;
    } Node;

    typedef struct list {
        ListNode *head;
    } Stack;
于 2014-04-14T17:15:32.570 回答