制作一个接受C中任何类型的动态数组

Question

我正在尝试找到一种方法来制作一个结构来保存一个可以使用任何数据类型（包括用户定义的数据类型）的动态数组，到目前为止，这就是我想出的方法。

#define Vector(DATATYPE) struct {   DATATYPE* data; size_t size; size_t used; }

typedef Vector(int) int_Vector;

int main(int argc, char* argv[]){
    int_Vector vec;
    return 0;
}

虽然这很有效，但我想知道，这是好的做法吗？我应该做这样的事情还是有更好的方法？还有一种方法可以在不使用 typedef Vector(int) int_vector 部分的情况下实现这一点。基本上是一种使我能够像 c++ 使用模板一样使用数组的方法，它看起来像这样：

#define Vector(DATATYPE) struct {   DATATYPE* data; size_t size; size_t used; }

int main(int argc, char* argv[]){
    Vector(int) vec;
    return 0;
}

主要是为了避免这么多的 typedef 并把它们都放在一个名字下。

Answer 1

嗯，不，C 没有模板系统，所以你不能使用。

您可以像您一样使用宏来模拟效果（非常聪明的解决方案），但这当然有点 non-standard 并且需要您的代码的用户学习宏及其局限性。

通常 C 代码不会尝试，因为它太笨拙了。

最 "generic" 典型的矢量类似于 glib 的 GArray，但它不会假装知道每个元素的类型。而是留给用户在访问时关心，数组只是将每个元素建模为 n 字节。

C11 中的 _Generic() 可能有点帮助，老实说，我在这方面不是很有经验。

Answer 2

第二个示例将不起作用，因为这两个变量被定义为不同的类型，即使它们的成员相同。为什么会这样，在我的 .

中有介绍

然而，使用稍微不同的方法可以使语法保持不变：

#include <stdlib.h>

#define vector(type)    struct vector_##type

struct vector_int
{
    int* array;
    size_t count;
} ;

int main(void)
{
    vector(int) one = { 0 };
    vector(int) two = { 0 };

    one = two;
    ( void )one ;

    return 0;
}

用法与 C++ 的 vector<int> 惊人地相似，可以在此处查看完整示例：

#include <stdlib.h>

#define vector_var(type)    struct vector_##type

struct vector_int
{
    int* array;
    size_t count;
};

void vector_int_Push( struct vector_int* object , int value ) 
{
    //implement it here
}

int vector_int_Pop( struct vector_int* object ) 
{
    //implement it here
    return 0;
}    

struct vector_int_table
{
    void( *Push )( struct vector_int* , int );
    int( *Pop )( struct vector_int* );

} vector_int_table = { 
                         .Push = vector_int_Push ,
                         .Pop = vector_int_Pop 
                     };

#define vector(type)   vector_##type##_table

int main(void)
{
    vector_var(int) one = { 0 };
    vector_var(int) two = { 0 };

    one = two;

    vector(int).Push( &one , 1 );
    int value = vector(int).Pop( &one );
    ( void )value;

    return 0;
}

Answer 3

不错。而且我看不出有什么缺点。只是为了解释另一种方法，在这种情况下最常用的是使用 union:

typedef union { int i; long l; float f; double d; /*(and so on)*/} vdata;
typedef enum  {INT_T,LONG_T,FLOAT_T, /*(and so on)*/} vtype;
typedef struct 
{
    vtype t;
    vdata data
} vtoken;
typedef struct
{
    vtoken *tk;
    size_t sz;
   size_t n;
} Vector;

所以这是可行的方法。数据类型的枚举，你可以避免使用typedefs，但如果你使用混合（例如：sum long，to double，to float等）你必须使用它们，因为int + double不等于double + int;这也是一个原因，因为更容易看到工会做这个工作。你保持所有算术规则不变。

Answer 4

Vector(DATATYPE) struct { DATATYPE* data; size_t size; size_t used; } 函数指针也失败。

void* 对于指向任何对象的指针来说已经足够且定义明确，但对于指向函数的指针则不然。

C 确实允许将指向一种类型的函数的指针保存为指向另一种类型的函数的指针。通过使用下面两个中的 union，代码有足够的 space 来保存指向任何类型的指针。使用什么类型和使用什么成员的管理保持开放。

union u_ptr {
  void *object;
  void (*function)();
}

Answer 5

扩展关于多态性的解决方案，我们也可以让它包含指针类型或user-defined类型。这种方法的主要优点是摆脱了 "data type" 枚举以及所有 run-time 检查 switch 语句。

variant.h

#ifndef VARIANT_H
#define VARIANT_H

#include <stdio.h>
#include <stdint.h>

typedef void print_data_t (const void* data);
typedef void print_type_t (void);

typedef struct 
{
  void* data;
  print_data_t* print_data;
  print_type_t* print_type;
} variant_t;

void print_data_char    (const void* data);
void print_data_short   (const void* data);
void print_data_int     (const void* data);
void print_data_ptr     (const void* data);
void print_data_nothing (const void* data);

void print_type_char        (void);
void print_type_short       (void);
void print_type_int         (void);
void print_type_int_p       (void);
void print_type_void_p      (void);
void print_type_void_f_void (void);

void print_data (const variant_t* var);
void print_type (const variant_t* var);

#define variant_init(var) {                \
  .data = &var,                            \
                                           \
  .print_data = _Generic((var),            \
    char:  print_data_char,                \
    short: print_data_short,               \
    int:   print_data_int,                 \
    int*:  print_data_ptr,                 \
    void*: print_data_ptr,                 \
    void(*)(void): print_data_nothing),    \
                                           \
  .print_type = _Generic((var),            \
    char:  print_type_char,                \
    short: print_type_short,               \
    int:   print_type_int,                 \
    int*:  print_type_int_p,               \
    void*: print_type_void_p,              \
    void(*)(void): print_type_void_f_void) \
}


#endif /* VARIANT_H */

variant.c

#include "variant.h"

void print_data_char    (const void* data) { printf("%c",  *(const char*)  data); }
void print_data_short   (const void* data) { printf("%hd", *(const short*) data); }
void print_data_int     (const void* data) { printf("%d",  *(const int*)   data); }
void print_data_ptr     (const void* data) { printf("%p",  data); }
void print_data_nothing (const void* data) {}

void print_type_char        (void) { printf("char");          }
void print_type_short       (void) { printf("short");         }
void print_type_int         (void) { printf("int");           }
void print_type_int_p       (void) { printf("int*");          }
void print_type_void_p      (void) { printf("void*");         }
void print_type_void_f_void (void) { printf("void(*)(void)"); }


void print_data (const variant_t* var)
{
  var->print_data(var->data);
}

void print_type (const variant_t* var)
{
  var->print_type();
}

main.c

#include <stdio.h>
#include "variant.h"

int main (void) 
{
  char c = 'A';
  short s = 3;
  int i = 5;
  int* iptr = &i;
  void* vptr= NULL;
  void (*fptr)(void) = NULL;

  variant_t var[] =
  {
    variant_init(c),
    variant_init(s),
    variant_init(i),
    variant_init(iptr),
    variant_init(vptr),
    variant_init(fptr)
  };

  for(size_t i=0; i<sizeof var / sizeof *var; i++)
  {
    printf("Type: ");
    print_type(&var[i]);
    printf("\tData: ");
    print_data(&var[i]);
    printf("\n");
  }

  return 0;
}

输出：

Type: char      Data: A
Type: short     Data: 3
Type: int       Data: 5
Type: int*      Data: 000000000022FD98
Type: void*     Data: 000000000022FDA0
Type: void(*)(void)     Data:

用于此目的的 _Generic 的缺点是它阻止我们使用私有封装，因为它必须用作宏才能传递类型信息。

另一方面，在这种情况下，"variant" 必须为人们提出的所有新类型进行维护，因此它不是那么实用或通用。

为了各种类似的目的，了解这些技巧仍然很不错。

制作一个接受C中任何类型的动态数组

Making a dynamic array that accepts any type in C

c

dynamic-arrays