C++ 转换C+的向量+；到C

我正在尝试转换矢量名；cpp在C语言中的实现 事实上，我必须使用C中的一些函数，比如VECtrNE.PASSUBACK（String），但是如何做到这一点，没有合适的实现，我们有没有办法使用C++库并将它贴补到C代码中，这是我的想法。

typedef struct vector_ {
      void** data;
      int size;
      int count;
} vector;

void vector_add(vector*, void*);
void vector_add(vector *v, void *e)
{
    if (v->size == 0) {
        v->size = 10;
        v->data = malloc(sizeof(void*) * v->size);
        memset(v->data, '\0', sizeof(void*) * v->size);
    }

    if (v->size == v->count) {
        v->size *= 2;
        v->data = realloc(v->data, sizeof(void*) * v->size);
    }

    v->data[v->count] = e;
    v->count++;
}

例如：

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

#define DEF_VECTOR(type) \
typedef struct vector_##type { \
  type * data; \
  size_t alloc_size; \
  size_t size; \
} vector_##type; \
\
void init_vector_##type(vector_##type * vector) \
{ \
  vector->data = NULL; \
  vector->alloc_size = vector->size = 0; \
} \
\
void clear_vector_##type(vector_##type * vector) \
{ \
  if (vector->data != NULL) {\
    free(vector->data); \
    init_vector_##type(vector);  \
  } \
} \
\
void push_back_vector_##type(vector_##type * vector, type value) \
{ \
  if (vector->size == vector->alloc_size) { \
    vector->alloc_size = (vector->alloc_size == 0) ? 16 : vector->alloc_size * 2; \
    vector->data = realloc(vector->data, vector->alloc_size * sizeof(type)); \
     \
    if (vector->data == NULL) { \
      /* do what you want */ \
    } \
  } \
  vector->data[vector->size++] = value; \
} \
\
type at_vector_##type(vector_##type * vector, size_t index) \
{ \
  if (index >= vector->size) { \
    /* do what you want */ \
  } \
  return vector->data[index]; \
}

DEF_VECTOR(int)

int main()
{
  vector_int v;

  init_vector_int(&v);
  push_back_vector_int(&v, 123);
  push_back_vector_int(&v, 456);
  printf("%d %d\n", at_vector_int(&v, 0), at_vector_int(&v, 1));
  printf("%d %d\n", v.data[0], v.data[1]);
  clear_vector_int(&v);
  return 0;
}

瓦尔格林死刑

当然，您必须不要忘记调用

init_vector_xx

，如果需要

clear_vector_xx

，并且在执行过程中出现错误时，使用宏定义所有内容都没有帮助，因为您没有行号等

在这里，我将所有内容都放在unique宏中，实际上最好有一个宏来定义结构和声明函数，另一个宏来定义函数，以便能够将其放在头文件和源文件中

有没有方法可以使用C++库，并将其粘贴到C代码中，不知何故

我不确定是否有可能回答这个问题。当然，你可以从它们的定义中得到一些想法，因为它们得到了很好的实现，但是你也冒着被你不需要翻译的复杂性淹没的风险

---

但是，如果你可以留在C++中，不要移动到C；-）p> 如果您想要类似于

std:：vector

的解决方案，则等效的

push_-back（char-ch）

解决方案可能是：

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

typedef struct vectorOfChar vector;
struct vectorOfChar {
    char *start;
    char *finish;
    char *end_of_storage;
};

vector vector_construct(void) {
    vector v = {0};
    return v;
}

void vector_destruct(vector *const vec) {
    free(vec->start);
}

char *vector_data(vector *const vec) {
    return vec->start;
}

void vector_push_back(vector *const vec, char const ch) {
    if (vec->finish != vec->end_of_storage) {
        *vec->finish = ch;
        ++vec->finish;
    } else {
        int const size = vec->finish - vec->start;
        int capacity = vec->end_of_storage - vec->start;
        capacity++;
        capacity *= 3;
        capacity /= 2;
        char *const new_area = realloc(vec->start, capacity);
        if (new_area == NULL) {
            // define how to handle out-of-memory
            exit(EXIT_FAILURE);
        }
        vec->start = new_area;
        vec->finish = new_area + size;
        vec->end_of_storage = new_area + capacity;
        vector_push_back(vec, ch);
    }
}

int main() {
    vector v = vector_construct();

    for (char c = 'a'; c <= 'z'; c++) {
        vector_push_back(&v, c);
    }
    vector_push_back(&v, '\0');

    printf("%s\n", vector_data(&v));

    vector_destruct(&v);

    return EXIT_SUCCESS;
}

#包括
#包括
typedef结构向量或char向量；
结构向量{
字符*开始；
字符*完成；
字符*存储的结束字符；
};
向量_构造（void）{
向量v={0}；
返回v；
}
无效向量_自毁（向量*常量向量）{
自由（矢量控制->启动）；
}
字符*向量_数据（向量*常量向量）{
返回vec->start；
}
无效向量推回（向量*常量向量，字符常量ch）{
if（vec->finish！=vec->结束存储）{
*vec->finish=ch；
++向量->完成；
}否则{
int const size=vec->finish-vec->start；
int capacity=vec->end\u of_storage-vec->start；
容量++；
容量*=3；
容量/=2；
char*const new_area=realloc（向量->开始，容量）；
如果（新面积==NULL）{
//定义如何处理内存不足
退出（退出失败）；
}
vec->start=新建区域；
vec->finish=新面积+尺寸；
vec->存储区结束=新存储区+容量；
矢量推回（矢量，ch）；
}
}
int main（）{
向量v=向量_构造（）；
对于C++（char c=‘a’；C STD:：vector很大程度上依赖于C++特性，如C构造简单的复制构造（当然是模板）。我不认为这会飞。我知道C DONTY有这些特性，这就是为什么我在第一个链接中这样做的原因。你想实现一个等价的代码<代码：：vector：：PuthOffBuffe（）。

（通用）或

std:：vector:：push_back（）

您知道存储时间的类型在哪里？主要问题是关于数据的类型，如果为每种需要的类型都有一个专用的向量xx，那么更安全的方法是。注意，您可以使用宏来定义适当的向量xx，而无需在每次我尝试实现某个特定类型（例如我想要da）时手动定义ta类型为字符@BoR

pi@raspberrypi:/tmp $ valgrind ./a.out
==11108== Memcheck, a memory error detector
==11108== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==11108== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==11108== Command: ./a.out
==11108== 
123 456
123 456
==11108== 
==11108== HEAP SUMMARY:
==11108==     in use at exit: 0 bytes in 0 blocks
==11108==   total heap usage: 2 allocs, 2 frees, 1,088 bytes allocated
==11108== 
==11108== All heap blocks were freed -- no leaks are possible
==11108== 
==11108== For counts of detected and suppressed errors, rerun with: -v
==11108== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 6 from 3)

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

typedef struct vectorOfChar vector;
struct vectorOfChar {
    char *start;
    char *finish;
    char *end_of_storage;
};

vector vector_construct(void) {
    vector v = {0};
    return v;
}

void vector_destruct(vector *const vec) {
    free(vec->start);
}

char *vector_data(vector *const vec) {
    return vec->start;
}

void vector_push_back(vector *const vec, char const ch) {
    if (vec->finish != vec->end_of_storage) {
        *vec->finish = ch;
        ++vec->finish;
    } else {
        int const size = vec->finish - vec->start;
        int capacity = vec->end_of_storage - vec->start;
        capacity++;
        capacity *= 3;
        capacity /= 2;
        char *const new_area = realloc(vec->start, capacity);
        if (new_area == NULL) {
            // define how to handle out-of-memory
            exit(EXIT_FAILURE);
        }
        vec->start = new_area;
        vec->finish = new_area + size;
        vec->end_of_storage = new_area + capacity;
        vector_push_back(vec, ch);
    }
}

int main() {
    vector v = vector_construct();

    for (char c = 'a'; c <= 'z'; c++) {
        vector_push_back(&v, c);
    }
    vector_push_back(&v, '\0');

    printf("%s\n", vector_data(&v));

    vector_destruct(&v);

    return EXIT_SUCCESS;
}