Я решил эту проблему в C до того, как C ++ приобрел шаблоны, и у меня все еще есть код.
Вы не можете определить действительно универсальный типобезопасный шаблон контейнера-T с макросами так, чтобы он полностью ограничивался заголовкомфайлы.Стандартный препроцессор не предоставляет средств для «проталкивания» и «выталкивания» макрокоманд, которые вам потребуются, чтобы сохранить их целостность через вложенные и последовательные контексты расширения.И вы столкнетесь с вложенными контекстами, как только вы попытаетесь съесть свою собачью еду, определив контейнер из контейнеров T.
Это можно сделать, как мы увидим, но как@immortal предполагает, что это влечет за собой создание отдельных файлов .h и .c для каждого требуемого значения T.Вы можете, например, определить полностью общий список T с макросами во встроенном файле, скажем, list_type.inl, а затем включить list_type.inl в каждую из пары небольших оболочек установки - list_float.h иlist_float.c - соответственно будет определять и реализовывать контейнер list-of-float.Аналогично для list-of-int, list-of-list-of-float, list-of-vector-of-list-of-double и так далее.
Схематический пример прояснит все.Но сначала просто получите полную меру задачи «съешь свою собачью еду».
Рассмотрим такой контейнер второго порядка как список-списков-штуковин.Мы хотим иметь возможность создавать их экземпляры, устанавливая T = list-of-thingummy для нашего макроса решения list-of-T.Но ни в коем случае список вещей не будет типом POD.Независимо от того, является ли list-thingummy нашим собственным собачьим кормом или чьим-либо еще, это будет абстрактный тип данных, который живет в куче и представляется его пользователям через тип указателя typedef-ed.Или, по крайней мере, динамические компоненты будут храниться в куче.В любом случае, не POD.
Это означает, что для нашего решения со списком T недостаточно просто сказать, что T = list-of-thingummy.Также необходимо указать, требуется ли для T создание и уничтожение без POD, и если да, то как его создать и уничтожить.В терминах C это означает:
Конструкция копирования: Как создать копию данного T в области T-размера незафиксированной памяти, учитывая адрес такого региона.
Уничтожение: Как уничтожить T по заданному адресу.
Мы можем обойтись без знания конструкции по умолчаниюили построение из не-T-параметров, поскольку мы можем разумно ограничить наше решение list-of-T сдерживанием объектов, скопированных из предоставленных пользователем оригиналов.Но мы должны их скопировать, и мы должны избавиться от наших копий.
Далее, предположим, что мы стремимся предложить шаблон для набора-T или map-of-T1-to-T2В дополнение к списку T.Эти упорядоченные по ключу типы данных добавляют еще один параметр, который мы должны подключить для любого не POD-значения T или T1, а именно, как упорядочить любые два объекта типа ключа.Действительно, нам понадобится этот параметр для любого ключевого типа данных, для которого memcmp() не подойдет.
Отметив это, мы остановимся на более простой задаче списка T для примера схемы;и для дальнейшей простоты я забуду о желательности любого const API.
Для этого и любого другого типа контейнера шаблона нам понадобятся некоторые макросы вставки токенов, которые позволят нам удобно собирать идентификаторы функций и типов, плюс, вероятно, другие полезные макросы.Все они могут идти в заголовке, скажем, macro_kit.h, например:
#ifndef MACRO_KIT_H
#define MACRO_KIT_H
/* macro_kit.h */
#define _CAT2(x,y) x##y
// Concatenate 2 tokens x and y
#define CAT2(x,y) _CAT2(x,y)
// Concatenate 3 tokens x, y and z
#define CAT3(x,y,z) CAT2(x,CAT2(y,z))
// Join 2 tokens x and y with '_' = x_y
#define JOIN2(x,y) CAT3(x,_,y)
// Join 3 tokens x, y and z with '_' = x_y_z
#define JOIN3(x,y,z) JOIN2(x,JOIN2(y,z))
// Compute the memory footprint of n T's
#define SPAN(n,T) ((n) * sizeof(T))
#endif
Теперь к схематической структуре list_type.inl:
//! There is intentionally no idempotence guard on this file
#include "macro_kit.h"
#include <stddef.h>
#ifndef INCLUDE_LIST_TYPE_INL
#error This file should only be included from headers \
that define INCLUDE_LIST_TYPE_INL
#endif
#ifndef LIST_ELEMENT_TYPE
#error Need a definition for LIST_ELEMENT_TYPE
#endif
/* list_type.inl
Defines and implements a generic list-of-T container
for T the current values of the macros:
- LIST_ELEMENT_TYPE:
- must have a definition = the datatype (or typedef alias) for \
which a list container is required.
- LIST_ELEMENT_COPY_INITOR:
- If undefined, then LIST_ELEMENT_TYPE is assumed to be copy-
initializable by the assignment operator. Otherwise must be defined
as the name of a copy initialization function having a prototype of
the form:
LIST_ELEMENT_TYPE * copy_initor_name(LIST_ELEMENT_TYPE *pdest,
LIST_ELEMENT_TYPE *psrc);
that will attempt to copy the LIST_ELEMENT_TYPE at `psrc` into the
uncommitted memory at `pdest`, returning `pdest` on success and NULL
on failure.
N.B. This file itself defines the copy initializor for the list-type
that it generates.
- LIST_ELEMENT_DISPOSE
If undefined, then LIST_ELEMENT_TYPE is assumed to need no
destruction. Otherwise the name of a destructor function having a
protoype of the form:
void dtor_name(LIST_ELEMENT_TYPE pt*);
that appropriately destroys the LIST_ELEMENT_TYPE at `pt`.
N.B. This file itself defines the destructor for the list-type that
it generates.
*/
/* Define the names of the list-type to generate,
e.g. list_int, list_float
*/
#define LIST_TYPE JOIN2(list,LIST_ELEMENT_TYPE)
/* Define the function-names of the LIST_TYPE API.
Each of the API macros LIST_XXXX generates a function name in
which LIST becomes the value of LIST_TYPE and XXXX becomes lowercase,
e.g list_int_new
*/
#define LIST_NEW JOIN2(LIST_TYPE,new)
#define LIST_NODE JOIN2(LIST_TYPE,node)
#define LIST_DISPOSE JOIN2(LIST_TYPE,dispose)
#define LIST_COPY_INIT JOIN2(LIST_TYPE,copy_init)
#define LIST_COPY JOIN2(LIST_TYPE,copy)
#define LIST_BEGIN JOIN2(LIST_TYPE,begin)
#define LIST_END JOIN2(LIST_TYPE,end)
#define LIST_SIZE JOIN2(LIST_TYPE,size)
#define LIST_INSERT_BEFORE JOIN3(LIST_TYPE,insert,before)
#define LIST_DELETE_BEFORE JOIN3(LIST_TYPE,delete,before)
#define LIST_PUSH_BACK JOIN3(LIST_TYPE,push,back)
#define LIST_PUSH_FRONT JOIN3(LIST_TYPE,push,front)
#define LIST_POP_BACK JOIN3(LIST_TYPE,pop,back)
#define LIST_POP_FRONT JOIN3(LIST_TYPE,pop,front)
#define LIST_NODE_GET JOIN2(LIST_NODE,get)
#define LIST_NODE_NEXT JOIN2(LIST_NODE,next)
#define LIST_NODE_PREV JOIN2(LIST_NODE,prev)
/* Define the name of the structure used to implement a LIST_TYPE.
This structure is not exposed to user code.
*/
#define LIST_STRUCT JOIN2(LIST_TYPE,struct)
/* Define the name of the structure used to implement a node of a LIST_TYPE.
This structure is not exposed to user code.
*/
#define LIST_NODE_STRUCT JOIN2(LIST_NODE,struct)
/* The LIST_TYPE API... */
// Define the abstract list type
typedef struct LIST_STRUCT * LIST_TYPE;
// Define the abstract list node type
typedef struct LIST_NODE_STRUCT * LIST_NODE;
/* Return a pointer to the LIST_ELEMENT_TYPE in a LIST_NODE `node`,
or NULL if `node` is null
*/
extern LIST_ELEMENT_TYPE * LIST_NODE_GET(LIST_NODE node);
/* Return the LIST_NODE successor of a LIST_NODE `node`,
or NULL if `node` is null.
*/
extern LIST_NODE LIST_NODE_NEXT(LIST_NODE node);
/* Return the LIST_NODE predecessor of a LIST_NODE `node`,
or NULL if `node` is null.
*/
extern LIST_NODE LIST_NODE_PREV(LIST_NODE node);
/* Create a new LIST_TYPE optionally initialized with elements copied from
`start` and until `end`.
If `end` is null it is assumed == `start` + 1.
If `start` is not NULL then elements will be appended to the
LIST_TYPE until `end` or until an element cannot be successfully copied.
The size of the LIST_TYPE will be the number of successfully copied
elements.
*/
extern LIST_TYPE LIST_NEW(LIST_ELEMENT_TYPE *start, LIST_ELEMENT_TYPE *end);
/* Dispose of a LIST_TYPE
If the pointer to LIST_TYPE `plist` is not null and addresses
a non-null LIST_TYPE then the LIST_TYPE it addresses is
destroyed and set NULL.
*/
extern void LIST_DISPOSE(LIST_TYPE * plist);
/* Copy the LIST_TYPE at `psrc` into the LIST_TYPE-sized region at `pdest`,
returning `pdest` on success, else NULL.
If copying is unsuccessful the LIST_TYPE-sized region at `pdest is
unchanged.
*/
extern LIST_TYPE * LIST_COPY_INIT(LIST_TYPE *pdest, LIST_TYPE *psrc);
/* Return a copy of the LIST_TYPE `src`, or NULL if `src` cannot be
successfully copied.
*/
extern LIST_TYPE LIST_COPY(LIST_TYPE src);
/* Return a LIST_NODE referring to the start of the
LIST_TYPE `list`, or NULL if `list` is null.
*/
extern LIST_NODE LIST_BEGIN(LIST_TYPE list);
/* Return a LIST_NODE referring to the end of the
LIST_TYPE `list`, or NULL if `list` is null.
*/
extern LIST_NODE LIST_END(LIST_TYPE list);
/* Return the number of LIST_ELEMENT_TYPEs in the LIST_TYPE `list`
or 0 if `list` is null.
*/
extern size_t LIST_SIZE(LIST_TYPE list);
/* Etc. etc. - extern prototypes for all API functions.
...
...
*/
/* If LIST_IMPLEMENT is defined then the implementation of LIST_TYPE is
compiled, otherwise skipped. #define LIST_IMPLEMENT to include this
file in the .c file that implements LIST_TYPE. Leave it undefined
to include this file in the .h file that defines the LIST_TYPE API.
*/
#ifdef LIST_IMPLEMENT
// Implementation code now included.
// Standard library #includes...?
// The heap structure of a list node
struct LIST_NODE_STRUCT {
struct LIST_NODE_STRUCT * _next;
struct LIST_NODE_STRUCT * _prev;
LIST_ELEMENT_TYPE _data[1];
};
// The heap structure of a LIST_TYPE
struct LIST_STRUCT {
size_t _size;
struct LIST_NODE_STRUCT * _anchor;
};
/* Etc. etc. - implementations for all API functions
...
...
*/
/* Undefine LIST_IMPLEMENT whenever it was defined.
Should never fall through.
*/
#undef LIST_IMPLEMENT
#endif // LIST_IMPLEMENT
/* Always undefine all the LIST_TYPE parameters.
Should never fall through.
*/
#undef LIST_ELEMENT_TYPE
#undef LIST_ELEMENT_COPY_INITOR
#undef LIST_ELEMENT_DISPOSE
/* Also undefine the "I really meant to include this" flag. */
#undef INCLUDE_LIST_TYPE_INL
Обратите внимание, что list_type.inl имеетнет макро-предохранителя от включения мутлипа.Вы хотите, чтобы по крайней мере некоторые из них - по крайней мере API-интерфейс шаблона - включались каждый раз, когда его видели.
Если вы читаете комментарии в верхней части файла, вы можете догадаться, как вы будете кодировать заголовок переноса.чтобы импортировать тип контейнера list-of-int.
#ifndef LIST_INT_H
#define LIST_INT_H
/* list_int.h*/
#define LIST_ELEMENT_TYPE int
#define INCLUDE_LIST_TYPE_INL
#include "list_type.inl"
#endif
, а также как вы будете кодировать заголовок переноса для импорта типа контейнера list-of-list-of-int:
#ifndef LIST_LIST_INT_H
#define LIST_LIST_INT_H
/* list_list_int.h*/
#define LIST_ELEMENT_TYPE list_int
#define LIST_ELEMENT_COPY_INIT list_int_copy_init
#define LIST_ELEMENT_DISPOSE list_int_dispose
#define INCLUDE_LIST_TYPE_INL
#include "list_type.inl"
#endif
Ваши приложения могут безопасно включать такие оболочки, например,
#include "list_int.h"
#include "list_list_int.h"
несмотря на то, что они определяют LIST_ELEMENT_TYPE противоречивым образом, потому что
list_type.inl всегда #undefs все макросы, которые параметризуют тип списка
когда это будет сделано с ними: посмотрите последние несколько строк файла.
Обратите внимание также на использование макроса LIST_IMPLEMENT. Если его не определено, когда list_type.inl
анализируется, тогда выставляется только шаблон API; реализация шаблона
пропускаются. Если определено LIST_IMPLEMENT, то весь файл компилируется. Таким образом, наш
заголовки переноса, не определяя LIST_IMPLEMENT, импортировать только тип списка
API.
И наоборот, для упаковки исходных файлов list_int.c, list_list_int.c мы будем
определить LIST_IMPLEMENT. После этого ничего не остается, кроме как включить
соответствующий заголовок:
/* list_int.c */
#define LIST_IMPLEMENT
#include "list_int.h"
и
/* list_list_int.c*/
#include "list_int.h"
#define LIST_IMPLEMENT
#include "list_list_int.h"
Теперь в вашем приложении макросы шаблонов списков не отображаются. Ваша упаковка
заголовки разбираются на «реальный код»:
#include "list_int.h"
#include "list_list_int.h"
// etc.
int main(void)
{
int idata[10] = {1,2,3,4,5,6,7,8,9,10};
//...
list_int lint = list_int_new(idata,idata + 10);
//...
list_list_int llint = list_list_int_new(&lint,0);
//...
list_int_dispose(&lint);
//...
list_list_int_dispose(&llint);
//...
exit(0);
}
Оснащение себя "библиотекой шаблонов C" таким образом единственный (!) Тяжелый труд
написать файл .inl для каждого типа контейнера и проверить его
очень, очень тщательно. Тогда вы, вероятно, сгенерируете объектный файл
и заголовок для каждой комбинации собственного типа данных и типа контейнера для
готовую связь, и в одно мгновение выбить обертки .h и .c
другие виды по запросу.
Само собой разумеется, как только C ++ вырастил шаблоны, мой энтузиазм потеет
их таким образом испарились. Но это можно сделать таким образом, полностью
как правило, если по какой-то причине C является единственным вариантом.