Создание динамического массива, который принимает любой тип в C

Я пытаюсь найти способ сделать структуру для хранения динамического массива, который может работать с любым типом данных (включая определенные пользователем типы данных), до сих пор это то, что я придумал.

#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. В основном способ, который позволит мне использовать массив так же, как С++ использует шаблоны, где он будет выглядеть примерно так:

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

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

В основном, чтобы избежать так много typedefs и иметь все под одним именем.

Ответ 1

Ну нет, C не имеет системы шаблонов, поэтому вы не можете ее использовать.

Вы можете имитировать эффекты с помощью макросов, как и вы (довольно умное решение), но это, конечно, немного нестандартное и требует, чтобы пользователи вашего кода изучали макрос и его ограничения.

Обычно код C не пытается, так как это так неудобно.

Самый "общий" типичный вектор - это что-то вроде glib GArray, но это не претендует на то, чтобы знать тип каждого элемента, Вместо этого пользователю остается только заботиться о доступе, и массив просто моделирует каждый элемент как n байты.

Там _Generic() в C11, который может немного помочь, я честно не очень разбираюсь в этом.

Ответ 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;
}

Использование, удивительно похожее на С++ 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;
}

Ответ 3

Vector(DATATYPE) struct { DATATYPE* data; size_t size; size_t used; } также не работает для указателей на функции.

void* является достаточным и корректным для указателя на любой объект, но не для указателя на функцию.

C позволяет указывать указатель на функцию одного типа как указатель на функцию другого типа. Используя union двух ниже, код имеет достаточно места для сохранения указателя на любой тип. Управление типом и используемым элементом остается открытым.

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

Ответ 4

Неплохо. И я не вижу недостатка. Просто для объяснения другого метода, чаще всего используемого в этом случае, используйте 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, но если вы используете смешанный (ex: sum long, double, to float и т.д.), Вы должны использовать их, поскольку int + double не равно double + int; Это также является причиной, потому что легче видеть, как профсоюзы выполняют эту работу. Вы оставляете арифметические правила нетронутыми.

Ответ 5

Развернув этот ответ в отношении решения полиморфизма, мы можем также включить его в типы указателей или пользовательские типы. Основное преимущество этого метода состоит в том, чтобы избавиться от перечисления "тип данных" и с ним все операторы переключения времени выполнения.

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 для этой цели заключаются в том, что он блокирует использование частной инкапсуляции, поскольку она должна использоваться как макрос, чтобы передавать информацию о типе.

С другой стороны, "вариант" в этом случае должен поддерживаться для всех новых типов, с которыми вы сталкиваетесь, поэтому это не все, что практически или вообще.

Тем не менее эти трюки хороши для разных целей.