我重新开始使用C语言，但是我已经被其他语言中的泛型所宠坏了。在我实现可调整大小的数组时，我已经写出了以下的代码：
typdef struct {
void** array;
int length;
int capacity;
size_t type_size;
} Vector;
void vector_add(Vector* v, void* entry) {
// ... code for adding to the array and resizing
}
int main() {
Vector* vector = vector_create(5, sizeof(int));
vector_add(vector, 4); // This is erroneous...
// ...
}
val n = num(42);
val的表示方式，它只占用一个机器字。几位类型标记被用来区分数字、指针、字符等。val n = num_fast(42);
这个宏（位操作宏）要快得多，因为它没有进行任何特殊检查以确保数字42适合“fixnum”范围；它用于小整数。
一个将其参数添加到向量的每个元素的函数可以像这样编写（非常低效）：
val vector_add(val vec, val delta)
{
val iter;
for (iter = zero; lt(iter, length(vec)); iter = plus(iter, one)) {
val *pelem = vecref_l(vec, iter);
*pelem = plus(*pelem, delta);
}
return nil;
}
plus是通用的，因此它可以与fixnums、bignums和实数一起使用，也可以与字符一起使用，因为通过plus可以向字符添加整数位移。vec不是可以应用length的东西，length将抛出异常。_l后缀的函数返回一个位置。而vecref(v, i)返回向量v中偏移量i处的值，vecref_l(v, i)返回存储该值的val类型位置的指针。val这样的类型，但您可以在支持的体系结构和编译器中相当可移植地完成。vector_add不够通用。有可能做得更好：val sequence_add(val vec, val delta)
{
val iter;
for (iter = zero; lt(iter, length(vec)); iter = plus(iter, one)) {
val elem = ref(vec, iter);
refset(vec, iter, plus(elem, delta));
}
return nil;
}
ref和refset，现在它也适用于列表和字符串，而不仅仅是向量。我们可以这样做：val str = string(L"abcd");
sequence_add(str, num(2));
str 的内容将会发生改变，因为每个字符都会被原地加上位移量 2，最终结果为 cdef。
int *new_int = (int*)malloc(sizeof(int));
*new_int = 4;
vector_add(vector, new_int);
自然而然，编写一个int *create_int(int x)函数或类似函数是一个好主意：
int *create_int(int x)
{
int *n = (int*)malloc(sizeof(int));
*n = 4;
return n;
}
//...
vector_add(vector, create_int(4));
您可以通过存储数据而不是指向数据的指针来避免许多小的分配，例如：
typedef struct {
char* array;
int length;
int capacity;
size_t type_size;
} Vector;
bool vector_add(Vector* v, void* entry)
{
if (v->length < v->capacity || vector_expand(v)) {
char* location = v->array + (v->length++)*(v->type_size);
memcpy(location, entry, v->type_size);
return 1;
}
return 0; // didn't fit
}
int main()
{
Vector* vector = vector_create(5, sizeof(int));
int value = 4;
vector_add(vector, &value); // pointer to local is ok because the pointer isn't stored, only used for memcpy
}
bool vector_add(Vector *v, void *entry)。 - Jens是的，这是我的一个实现（与你的类似），可能会有所帮助。它使用可以用函数调用包装的宏来处理即时值。
#ifndef VECTOR_H
# define VECTOR_H
# include <stddef.h>
# include <string.h>
# define VECTOR_HEADROOM 4
/* A simple library for dynamic
* string/array manipulation
*
* Written by: Taylor Holberton
* During: July 2013
*/
struct vector {
void * data;
size_t size, len;
size_t headroom;
};
int vector_init (struct vector *);
size_t vector_addc (struct vector *, int index, char c);
size_t vector_subc (struct vector *, int index);
// these ones are just for strings (I haven't yet generalized them)
size_t vector_adds (struct vector *, int index, int iend, const char * c);
size_t vector_subs (struct vector *, int ibegin, int iend);
size_t vector_addi (struct vector *, int index, int i);
size_t vector_subi (struct vector *, int index);
# define vector_addm(v, index, datatype, element) \
do { \
if (!v) return 0; \
\
if (!v->size){ \
v->data = calloc (v->headroom, sizeof (datatype)); \
v->size = v->headroom; \
} \
\
datatype * p = v->data; \
\
if (v->len >= (v->size - 2)){ \
v->data = realloc (v->data, \
(v->size + v->headroom) * sizeof (datatype)); \
p = v->data; \
memset (&p[v->size], 0, v->headroom * sizeof(datatype));\
v->size += v->headroom; \
} \
\
if ((index < 0) || (index > v->len)){ \
index = v->len; \
} \
\
for (int i = v->len; i >= index; i--){ \
p[i + 1] = p[i]; \
} \
\
p[index] = element; \
\
v->len++; \
\
} while (0)
# define vector_subm(v, index, datatype) \
do { \
if (!v || !v->len){ \
return 0; \
} \
\
if ((index < 0) || (index > (v->len - 1))){ \
index = v->len - 1; \
} \
\
datatype * p = v->data; \
\
for (int i = index; i < v->len; i++){ \
p[i] = p[i + 1]; \
} \
\
v->len--; \
\
if ((v->size - v->len) > v->headroom){ \
v->data = realloc (v->data, ((v->size - v->headroom) + 1) * sizeof (datatype));\
v->size -= v->headroom; \
} \
\
} while (0)
#endif
size_t vector_addi (struct vector * v, int index, int i){
vector_addm (v, index, int, i);
return v->len;
}
valgrind）。stdarg.h来做同样的事情，但我从未尝试过。stdarg.h，因为我认为你也可以用它来实现。它允许你使用任意数量的参数而没有特定的类型。 - tay10r我希望有类型安全的通用容器（其他语言会提供正确的泛型（Ada）或参数多态（OCaml））。这是 C 语言中最缺失的功能。
宏无法实现这一点（我不打算详细解释。简单地说：模板扩展或通用实例化的结果应该是一个独立的模块：在 C 中，这意味着有预处理器符号导出或可用于模块配置（如 -DUSE_PROCESS_QUEUE_DEBUGCODE），如果使用 C 宏生成实例，就无法做到这一点。
通过将元素大小和所有相关操作移入描述性结构来抽象元素类型。这将传递给每个通用代码调用。请注意，描述符描述元素类型，因此每个通用实例需要一个描述符实例。
我正在使用模板处理器创建一个薄的类型安全前端模块，用于通用代码。
例如：
这是检索元素的通用代码原型：
void fifo_get ( fifo_DESCRIPTOR* inst, fifo* , void* var );
typedef struct fifo_DESCRIPTOR {
size_t maxindex;
size_t element_size;
} fifo_DESCRIPTOR;
<<eT>> <<>>get ( <<T>>* f ) {
<<eT>> e; fifo_get( &DESCRIPTOR, (fifo*) f, (void*) &e ); return e;
}
float floatq_get ( floatq* f ) {
float e; fifo_get( &DESCRIPTOR, (fifo*) f, (void*) &e ); return e;
}
// vector.h
#ifndef VECTOR_H
#define VECTOR_H
#define VECTOR_IMP(itemType) \
typedef struct { \
itemType * array; \
int length; \
int capacity; \
} itemType##_Vector; \
\
static inline void itemType##_vector_add(itemType##_Vector* v, itemType v) { \
// implementation of adding an itemType object to the array goes here \
} \
\
[... other static-inline generic vector methods would go here ...] \
// Now we can "instantiate" versions of the Vector struct and methods for
// whatever types we want to use.
VECTOR_IMP(int);
VECTOR_IMP(float);
VECTOR_IMP(char);
#endif
#include "vector.h"
int main(int argc, char ** argv)
{
float_Vector fv = {0};
int_Vector iv = {0};
char_Vector cv = {0};
int_vector_add(&iv, 5);
float_vector_add(&fv, 3.14f);
char_vector_add(&cv, 'A');
return 0;
}
不要让向量类存储添加的对象，而是可以返回指针以便调用者可以将其存储到指定位置：
typdef struct {
char *buffer;
size_t length;
size_t capacity;
size_t type_size;
} Vector;
void *vector_add(Vector* v)
{
if (v->length == v->capacity) {
// ... increase capacity by at least one
// ... realloc buffer to capacity * type_size
}
return v->buffer + v->type_size * v->length++;
}
// in main:
*(int*)vector_add(v) = 4;
type_size字段似乎是多余的，因为你只能存储void*大小的数据。你可以选择存储任意固定一致大小的内存块，而不是存储指针。 - Ben Voigt