6

我有一个看起来像这样的代码（C++）

vector<int> values[10000];

int i, j; 
while (.....) {
    scanf("%d%d", &i, &j);
    values[i].push_back(j);
    values[j].push_back(i);
}

但我想将此代码重写为 C。我该怎么做？

我研究了制作自己的堆栈的机会，但也许有更轻量级的方式来重写这段代码，也许是二维数组。到目前为止我还想不出这个翻拍是怎么做的，我希望有经验的人告诉我怎么做:)

抱歉，伙计们，添加了一个更高级的示例...

4

8 回答 8

8

而不是自己滚动，您可能想尝试一个 C 容器库，例如http://code.google.com/p/ccl/

于 2012-12-29T17:44:21.343 回答
1

像这样的东西：

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


typedef struct _darray
{
    size_t size;
    size_t actual_size;
    int *content;
} darray;


void darray_create(darray *d)
{

    d->actual_size = d->size = 0;
    d->content = NULL;
}

void darray_append(darray *d, int v)
{
    if (d->size+1 > d->actual_size)
    {
    size_t new_size;
    if (!d->actual_size) 
    { 
        new_size = 1;
    }
    else
    {
        new_size = d->actual_size * 2;
    }
    int *temp = realloc(d->content, sizeof(int) * new_size);
    if (!temp)
    {
        fprintf(stderr, "Failed to extend array (new_size=%zu)\n", new_size);
        exit(EXIT_FAILURE);
    }
    d->actual_size = new_size;
    d->content = temp;
    }
    d->content[d->size] = v;
    d->size++;
}

const int* darray_data(darray *d)
{
    return d->content;
}


void darray_destroy(darray *d)
{
    free(d->content);
    d->content = NULL;
    d->size = d->actual_size = 0;
}


size_t darray_size(darray *d)
{
    return d->size;
}


int main()
{
    int i;
    darray myarray;
    const int *a;

    darray_create(&myarray);

    for(i = 0; i < 100; i++)
    {
    darray_append(&myarray, i);
    }
    a = darray_data(&myarray);
    for(i = 0; i < darray_size(&myarray); i++)
    {
    printf("i=%d, value=%d\n", i, a[i]);
    }
    darray_destroy(&myarray);
}
于 2012-12-29T20:28:50.547 回答
1

C++ 的粗略等价物vector是调整大小的 C 数组（以考虑比可用元素更多的元素）。

因此，向量数组的等价物将是指针数组（由于调整大小限制，数组数组不会削减它）。

int* values[1000];

不过，您需要考虑大小，因此您可以在外部执行此操作，也可以将逻辑包装在结构中。

int sizes[1000];
int noElements[1000];
// all sizes and noElements initially 0

for (int i = 0; i < 10; i++) {
    if ( noElements[i] >= sizes[i] )
    {
        // allocate more memory for values[i];
        // copy old contents into the new memory
        // update sizes[i]
    }
    values[i][noElements] = 10;
    noElements++;
}
于 2012-12-29T17:42:39.423 回答
1

你可以尝试这样的事情：

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


struct vector
{
    int len;
    int allocated;
    int step;
    int *data;
};


#define INIT_SIZE 1


void init_vector(struct vector *v)
{
    v->len = 0;
    v->allocated = 0;
    v->step = 2;
    v->data = NULL;
}


int append(struct vector *v, int item)
{
    if (!v->data)
    {
        v->data = malloc(INIT_SIZE * sizeof(int));

        if (!v->data)
            return -1;

        v->allocated = INIT_SIZE;
    }
    else
        if (v->len >= v-vallocated)
        {
            int *tmp = realloc(v->data, 
                        v->allocated * v->step * sizeof(int));

            if (!tmp)
                return -1;

            v->data = tmp;
            v->allocated *= v->step;
        }

    v->data[v->len] = item;
    v->len++;

    return 0;
}


int delete(struct vector *v, int index)
{
    if (index < 0 || index >= v->len)
        return -1;

    memmove(v->data + index, v->data + index + 1,
                      (v->len - index - 1) * sizeof(int));
    v->len--;

    return 0;
}


void print(const struct vector *v)
{
    printf("Array:\n");

    for (int i = 0; i < v->len; i++)
        printf("%d ", v->data[i]);

    printf("\n");
}


int main(void)
{
    struct vector v;
    int rc;

    init_vector(&v);

    rc = append(&v, 1);
    assert(rc == 0);

    rc = append(&v, 2);
    assert(rc == 0);

    rc = append(&v, 3);
    assert(rc == 0);

    rc = append(&v, 4);
    assert(rc == 0);

    rc = append(&v, 5);
    assert(rc == 0);

    print(&v);

    rc = delete(&v, 2);
    assert(rc == 0);

    print(&v);

    free(v.data);

    return 0;
}
于 2017-11-14T18:31:27.663 回答
1

你可以使用Gena图书馆。它与stl::vectorpure非常相似C89。

你可以在这里查看：

https://github.com/cher-nov/Gena

于 2020-11-24T07:51:28.383 回答
0

没有与 c++ 向量等效的 C 标准，尽管您可以基于 c++ 中的向量创建一个结构。该结构将

  • 如果数组边界超过最大大小，则调整自身大小
  • 执行类似于向量的操作

或者

  • 创建一个模拟 C++ 向量的链表堆栈结构
于 2012-12-29T17:42:13.250 回答
0

您必须使用动态内存分配。这并不难。每次必须插入新项目时，只需使用 realloc。有人认为看起来像这样：

#include <cstdlib>

typedef struct { } UserType;

int currentSize = 0;
UserType* values;

/// Add new value to values method
void addValue(const UserType& newValue)
{
    ++currentSize;
    values = static_cast<UserType*>(realloc(values, currentSize));
    if (values == NULL)
        // memory allocation filed, place fix code here
        *(values + currentSize) = newValue;
}

free请记住，您必须使用values. 此外，如果现在结束工作，您可能不会释放分配的内存。

于 2017-05-16T12:52:13.863 回答
0

我担心您将不得不以 80 年代的方式在普通 C 中使用堆内存。

typedef struct tagArrayDesc {
  int* arr;
  size_t top;
  size_t reserved;
} ArrayDesc;

#define EC(NAME, T) size_t ensure_capacity##NAME##(size_t size,            \
                                                   T** vec,                \
                                                   size_t reserved)        \
{                                                                          \
  size_t new_reserved;                                                     \
  new_reserved = reserved;                                                 \
  if (reserved < size) {                                                   \
    if (reserved != 0) {                                                   \
      new_reserved *= 2;                                                   \
    } else {                                                               \
      new_reserved = 0x10;                                                 \
    }                                                                      \
  }                                                                        \
  if (new_reserved < size) {                                               \
    new_reserved = (size * 4) / 3;                                         \
  }                                                                        \
  if (new_reserved > reserved) {                                           \
    *vec = realloc(*vec, sizeof(**vec) * new_reserved);                    \
    memset((*vec) + reserved, 0, sizeof(T) * (new_reserved - reserved));   \
  }                                                                        \
  return new_reserved;                                                     \
}

EC(_int, int)
EC(_array_desc, ArrayDesc)

int main()
{
  ArrayDesc* rows = NULL;
  size_t rows_size = 0;
  size_t rows_reserved = 0;
  while (true) {
    int i, j;
    scanf("%d%d", &i, &j);
    rows_reserved = ensure_capacity_array_desc(i + 1, &rows, rows_reserved);
    rows[i].reserved = ensure_capacity_int(j + 1, &rows[i].arr, rows[i].reserved);
    rows[i].arr[j] = 42;
  }
  return 0;
}
于 2015-12-10T20:48:41.627 回答