Generics in C?

MTK358 · 02-12-2010, 07:28 PM

I was thinking about how to make a dynamic array in C, and I thought that it would be much better if it could accept any data type. Is this possible? Of course I thought about void pointers, but how do I store the actual data?

Sergei Steshenko · 02-12-2010, 08:11 PM

Quote:

Originally Posted by MTK358

I was thinking about how to make a dynamic array in C, and I thought that it would be much better if it could accept any data type. Is this possible? Of course I thought about void pointers, but how do I store the actual data?

Use smart enough preprocessor - if you want compile time type checking.

MTK358 · 02-13-2010, 12:27 PM

But what if the generic code is precompiled, and the program that uses it just has the header?

paulsm4 · 02-13-2010, 01:13 PM

Hi, MTK358 -

I really don't understand your perverse fascination with taking C++ constructs and trying to implement them verbatim in C. In previous posts, it was C++ style inheritance. In this post, C++ style templates. I mean, you certainly *can*. In the same sense you can certainly eat stringbeans through your nose (if you try hard enough). But *why*????

Anyway: let's say you want a "generic linked list" (for example) in C. You want the *same* code to be able to handle *different* types, but you *also* want to "remember" the type as you store it in the list.

Easy. Many alternatives.

But arguably the simplest, most straightforward approach would be:

1. Have your linked list store pointers (duh!)
2. Always store a pointer to a "struct" (never a "bare primitive" like char or double)
3. Your struct contains a "tag" identifying the "type"
4. The same .h header that defines your struct also defines your "tags" (e.g. an enum of "known types").

IMHO .. PSM

PS:
alunduil and I posted almost exactly the same time. A union is of structs would also work, but I think you'd also probably need the tag, to retain knowledge of the original "type".

alunduil · 02-13-2010, 01:16 PM

In line with the previous post look into the union structure. It will allow you to handle mixed types in your list as well.

Regards,

Alunduil

Sergei Steshenko · 02-13-2010, 09:05 PM

Quote:

Originally Posted by MTK358

But what if the generic code is precompiled, and the program that uses it just has the header?

Perform web search on

RTTI

- and yes, you reinventing C++ or whatever.

Dan04 · 02-15-2010, 09:08 PM

A direct emulation of C++ templates would look something like:

Code:

#define DEF_ARRAY_TYPE(ARRAY_TYPE, ITEM_TYPE) \
   typedef struct { \
      size_t capacity; \
      site_t length; \
      ITEM_TYPE* data; \
   } ARRAY_TYPE; \
   ARRAY_TYPE* ARRAY_TYPE##new(void) { \
      ARRAY_TYPE* arr = malloc(sizeof(ARRAY_TYPE)); \
      arr->capacity = DEFAULT_CAPACITY; \
      arr->length = 0; \
      arr->data = calloc(DEFAULT_CAPACITY, sizeof(ITEM_TYPE)); \
      return arr; \
   } \
   void ARRAY_TYPE##_delete(ARRAY_TYPE* arr) \
   { \
      free(arr->data); \
      free(arr); \
   } \
   ITEM_TYPE ARRAY_TYPE##_getitem(ARRAY_TYPE* arr, size_t index) \
   { \
      return arr->data[index]; \
   } \
   void ARRAY_TYPE##_setitem(ARRAY_TYPE* arr, size_t index, ITEM_TYPE value) { \
      arr->data[index] = value; \
   } \
   // ...

DEF_ARRAY_TYPE(IntArray, int);

If you choose this approach, you might want to write a C pre-preprocessor.

Sergei Steshenko · 02-16-2010, 07:07 AM

Quote:

Originally Posted by Dan04

A direct emulation of C++ templates would look something like:

Code:

#define DEF_ARRAY_TYPE(ARRAY_TYPE, ITEM_TYPE) \
   typedef struct { \
      size_t capacity; \
      site_t length; \
      ITEM_TYPE* data; \
   } ARRAY_TYPE; \
   ARRAY_TYPE* ARRAY_TYPE##new(void) { \
      ARRAY_TYPE* arr = malloc(sizeof(ARRAY_TYPE)); \
      arr->capacity = DEFAULT_CAPACITY; \
      arr->length = 0; \
      arr->data = calloc(DEFAULT_CAPACITY, sizeof(ITEM_TYPE)); \
      return arr; \
   } \
   void ARRAY_TYPE##_delete(ARRAY_TYPE* arr) \
   { \
      free(arr->data); \
      free(arr); \
   } \
   ITEM_TYPE ARRAY_TYPE##_getitem(ARRAY_TYPE* arr, size_t index) \
   { \
      return arr->data[index]; \
   } \
   void ARRAY_TYPE##_setitem(ARRAY_TYPE* arr, size_t index, ITEM_TYPE value) { \
      arr->data[index] = value; \
   } \
   // ...

DEF_ARRAY_TYPE(IntArray, int);

If you choose this approach, you might want to write a C pre-preprocessor.

Further developing the approach - such generic things depend in reality not on type, but rather on sizeof(type). So a smarter preprocessor can really help - it will create new functions not for every new type, but for every new sizeof(type).

In a code of mine I am importing into Perl "C" numeric macros by creating a small test program which printf's the macro to be imported in the format of my choosing. I.e. the smart preprocessor can be made "C" types aware in such a manner.