无多态性优化C代码大小 我在这个网站上看到过C语言中的多态性，大多数评论员都不鼓励这样做，或者建议使用C++。我的结构和例程彼此非常相似，只是在成员和参数类型上有所不同。代码如下：

h文件：

typedef struct {
  double *array;
  size_t used;
  size_t size;
} dArray;
void init_dArray(dArray *a, size_t initialSize);
void insert_dArray(dArray *a, double element); 

typedef struct {
  char** array;
  size_t used;
  size_t size;
} sArray;
void init_sArray(sArray *a, size_t initialSize);
void insert_sArray(sArray *a, char* element); 

typedef struct {
  int* array;
  size_t used;
  size_t size;
} iArray;
void init_iArray(iArray *a, size_t initialSize);
void insert_iArray(iArray *a, int element); 

void free_dArray(dArray *a);
void free_sArray(sArray *a);
void free_iArray(iArray *a);

c文件：

void init_dArray(dArray *a, size_t initialSize) {
  a->array = (double *)malloc(initialSize * sizeof(double));
  a->used = 0;
  a->size = initialSize;
}

void init_sArray(sArray *a, size_t initialSize) {
  a->array = (char**)malloc(initialSize * sizeof(char*));
  a->used = 0;
  a->size = initialSize;
}

void init_iArray(iArray *a, size_t initialSize) {
  a->array = (int *)malloc(initialSize * sizeof(int));
  a->used = 0;
  a->size = initialSize;
}

void insert_dArray(dArray *a, double element) {
  if (a->used == a->size) {
    a->size = (a->size*3)/2+8;
    a->array = (double *)realloc(a->array, a->size * sizeof(double));
  }
  a->array[a->used++] = element;
}

void insert_sArray(sArray *a, char* element) {
  if (a->used == a->size) {
    a->size = (a->size*3)/2+8;
    a->array = (char**)realloc(a->array, a->size * sizeof(char*));
  }
  a->array[a->used++] = element;
}

void insert_iArray(iArray *a, int element) {
  if (a->used == a->size) {
    a->size = (a->size*3)/2+8;
    a->array = (int*)realloc(a->array, a->size * sizeof(int));
  }
  a->array[a->used++] = element;
}

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

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

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

主要内容：

#包括
#包括
内部主（空）
{
亚雷a；
初始值（&a，5）；
对于（int i=0；i您可以简单地抽象出元素的类型。数组需要知道的是这些元素有多大。您可以完全允许用户通过函数指针提供副本构造函数和析构函数，也可以将数组的范围限制为
memcpy（）
可移动类型

为普通数据元素提供数组
只需将元素的大小作为参数添加到数组
struct
：

typedef struct {
  char *array;
  size_t elementSize;
  size_t used;
  size_t size;
} Array;

void Array_init(Array *a, size_t elementSize, size_t initialSize);
void Array_insert(Array *a, const void* element);
const void* Array_at(Array *a, size_t index);
void Array_destruct(Array *a);

数组中的所有索引只是将索引与给定的元素大小相乘，以索引内部
char
数组。内部
char
指针隐式转换为接口的
void
指针，然后隐式转换为
double
指针或任何其他类型的指针插入此阵列

只要元素是可复制的，这就非常有效。如果元素本身需要管理内存，则需要以下方法：

为复杂数据元素提供数组
如果复制对象时需要执行自定义操作，则需要为用户提供一种方法来提供必要的行为。这是通过函数指针完成的：

typedef void (*Array_callback_copy_construct)(void* this, const void* original);
typedef void (*Array_callback_destruct)(void* this);
typedef struct {
  char *array;
  size_t elementSize;
  size_t used;
  size_t size;
  Array_callback_copy_construct copy_construct;
  Array_callback_destruct destruct;
} Array;

void Array_init(Array *a, size_t elementSize, size_t initialSize, Array_callback_copy_construct copy_construct, Array_callback_destruct destruct);
void Array_insert(Array *a, const void* element);
const void* Array_at(Array *a, size_t index);
void Array_destruct(Array *a);

Array\u insert（）
和
Array\u destruct（）
方法现在只需使用用户提供的回调函数来复制和销毁数组元素

更高级的版本还可能使用移动构造函数回调和/或（移动）分配回调。复制构造+销毁是您所需的最小集合，使用更高级的回调可以实现更好的性能


第一种方法非常简单，可以在各种各样的应用程序中使用，我会毫不犹豫地使用它。但是，必须清楚地记录
memcpy（）
的用法

第二种方法适用于第一种方法失败的情况，但通常情况下，这比它的价值要麻烦得多。除非您认为它确实是唯一的解决方案，否则请避免使用它。
注意，关于提高工作代码的质量或效率的问题更适合于以下情况：您是否担心代码行数、字节数在源文件中，或在编译的二进制文件中的字节数？如果只使用一个带有
类型
字段和嵌入的
联合
的结构，则可以消除冗余代码的某些部分。首先，您可以提取出容量检查（这三种类型都是相同的）。接下来，您可以对这三种情况实际使用一个过程，将插入值作为
void*
和元素大小的类型擦除组合传递给它。第三，通过利用这种超出合理范围的方法，您可以对每种数组类型使用相同的结构类型。这将是一种多态性，更像是运行时实现在这方面，宏可以是你的朋友。提供了一个使用C的方法的详细介绍。值得注意的是，对象大小作为结构中的第一个成员的位置，允许一个聪明的方法来分配和销毁对象。这不是直接的，而是一个很好的主题参考。
typedef void (*Array_callback_copy_construct)(void* this, const void* original);
typedef void (*Array_callback_destruct)(void* this);
typedef struct {
  char *array;
  size_t elementSize;
  size_t used;
  size_t size;
  Array_callback_copy_construct copy_construct;
  Array_callback_destruct destruct;
} Array;

void Array_init(Array *a, size_t elementSize, size_t initialSize, Array_callback_copy_construct copy_construct, Array_callback_destruct destruct);
void Array_insert(Array *a, const void* element);
const void* Array_at(Array *a, size_t index);
void Array_destruct(Array *a);