Хранение и использование информации о типах в C

Как правило, используются специальные функции, подобные приведенным ниже.

void    List_Put_int(list *L, int *i);
void    List_Put_double(list *L, double *d);
int *   List_Get_int(list *L);
double *List_Get_double(list *L);

В не очень простом для учащихся подходе используется _Generic. C11 предлагает _Generic, который позволяет управлять кодом во время компиляции по желанию в зависимости от типа.

Ниже приведен базовый код для сохранения/выборки до 3 типов указателей. Макросы потребуют расширения для каждого нового типа. _Generic не допускает перечисления 2 типов, которые могут быть одинаковыми, например unsigned * и size_t *. Так что есть ограничения.

Макрос type_id(X) создает перечисление для 3 типов, которые можно использовать для проверки наличия проблем во время выполнения, как с LIST_POP(L, &d); ниже.

typedef struct node {
  void *data;
  int type;
} node;

typedef struct list {
  node *head;
  node *tail;
} list;

node node_var;
void List_Push(list *l, void *p, int type) {
  // tbd code - simplistic use of global for illustration only
  node_var.data = p;
  node_var.type = type;
}

void *List_Pop(list *l, int type) {
  // tbd code
  assert(node_var.type == type);
  return node_var.data;
}

#define cast(X,ptr) _Generic((X), \
  double *: (double *) (ptr), \
  unsigned *: (unsigned *) (ptr), \
  int *: (int *) (ptr) \
  )

#define type_id(X) _Generic((X), \
  double *: 1, \
  unsigned *: 2, \
  int *: 3 \
  )

#define LIST_PUSH(L, data)  { List_Push((L),(data), type_id(data)); }
#define LIST_POP(L, dataptr) (*(dataptr)=cast(*dataptr, List_Pop((L), type_id(*dataptr))) )

Пример использования и вывод

int main() {
  list *L = 0; // tbd initialization
  int i = 42;
  printf("%p %d\n", (void*) &i, i);
  LIST_PUSH(L, &i);
  int *j;
  LIST_POP(L, &j);
  printf("%p %d\n", (void*) j, *j);
  double *d;
  LIST_POP(L, &d);
}

42
42
assertion error

В C нет способа сделать то, что вы хотите. Нет способа сохранить тип в переменной, и C не имеет системы шаблонов, такой как C++, которая позволила бы вам подделать его в препроцессоре.

Вы можете определить свои собственные шаблонные макросы, которые могли бы быстро определить ваши структуры node и list для любого типа, который вам нужен, но я думаю, что такой вид хакерства обычно осуждается, если вам действительно не нужна целая куча связанные списки, которые отличаются только типом, который они хранят.

C не имеет никакой информации о типе времени выполнения и не имеет типа «Тип». Типы не имеют смысла после того, как код был скомпилирован. Таким образом, нет решения того, о чем вы спрашиваете, предоставленного языком.

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

enum ElementType
{
    ET_INT; // int
    ET_DOUBLE; // double
    ET_CAR; // struct Car
    // ...
 };

и перечислите здесь любой тип, который когда-либо должен попасть в ваш контейнер. Другая причина заключается в том, что ваш контейнер должен стать владельцем хранящихся в нем объектов и, следовательно, должен знать, как их уничтожить (а иногда и как их клонировать). Для таких случаев я рекомендую использовать указатели на функции:

typedef void (*ElementDeleter)(void *element);
typedef void *(*ElementCloner)(const void *element);

Затем расширьте свою структуру, чтобы она содержала следующее:

typedef struct list {
    node *head;
    node *tail;
    ElementDeleter deleter;
    ElementCloner cloner;
} list;

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

myList->deleter(myNode->data);
// delete the contained element without knowing its type

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

В отличие от Java или C++, C не обеспечивает никакой безопасности типов. Чтобы кратко ответить на ваш вопрос, изменив тип узла следующим образом:

struct node {
   node* prev;  /* put these at front */
   node* next;
   /* no data here */
};

Затем вы можете отдельно объявить узлы, несущие любые данные

struct data_node {.
    data_node *prev;            // keep these two data members at the front 
    data_node *next;            // and in the same order as in struct list.

    // you can add more data members here.
};
/* OR... */
enter code here
struct data_node2 {
  node node_data;    /* WANING: this may look a bit safer, but is _only_ if placed at the front.
  /*  more data ... */
};

Затем вы можете создать библиотеку, которая работает со списками node без данных.

void list_add(list* l, node* n);
void list_remove(list* l, node* n);
/* etc... */

И путем кастинга используйте этот API-интерфейс «общие списки», чтобы выполнить операцию в вашем списке.

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

struct data_list
{
  data_node* head;    /* this makes intent clear. */
  data_node* tail;
};

struct data2_list
{
  data_node2* head;
  data_node2* tail;
};

/* ... */

data_node* my_data_node = malloc(sizeof(data_node));
data_node2* my_data_node2 = malloc(sizeof(data_node2));

/* ... */

list_add((list*)&my_list, (node*)my_data_node); 
list_add((list*)&my_list2, &(my_data_node2->node_data)); 

/* warning above is because one could write this */
list_add((list*)&my_list2, (node*)my_data_node2); 


/* etc... */

Эти два метода генерируют один и тот же объектный код, поэтому, какой из них вы выберете, на самом деле зависит от вас.

Кроме того, избегайте обозначения структуры typedef, если это позволяет ваш компилятор, что в наши дни делает большинство компиляторов. Это увеличивает читабельность в долгосрочной перспективе, ИМХО. Вы можете быть уверены, что некоторые этого не сделают, а некоторые согласятся со мной по этому вопросу.