Can macros be used to simulate C++ templated functions?

Answer 1

That should work. To create copy_key_sint, use copy_key_ ## sint.

If you can't get this to work with CPP, then write a small C program which generates a C source file.

Answer 2

Try something like this (I just tested the compilation, but not the result in an executed program):

 #include "memory.h"

   #define COPY_KEY(type, name)                                 \
   type name(void *key, void **args, int argc, void **out) { \
      if (*out = malloc(sizeof(type))) {                     \
         return 1;                                           \
      }                                                      \
   **((type **) out) = *((type *) key);                      \
   return 0;                                                 \
   }                                                         \

COPY_KEY(int, copy_key_sint)

For more on the subject of generic programming in C, read this blog wich contains a few examples and also this book which contains interesting solutions to the problem for basic data structures and algorithm.

Answer 3

Wouldn't a macro which just takes sizeof(*key) and calls a single function that uses memcpy be a lot cleaner (less preprocessor abuse and code bloat) than making a new function for each type just so it can do a native assignment rather than memcpy?

My view is that the whole problem is your attempt to apply C++ thinking to C. C has memcpy for a very good reason.

Answer 4

I don't understand the example function that you are giving very well, but using macros for the task is relatively easy. Just you wouldn't give strings to the macro as arguments but tokens:

#define DECLARE_MY_COPY_FUNCTION(TYPE, SUFFIX)              \
int copy_function_ ## SUFFIX(unsigned count, TYPE* arg)

#define DEFINE_MY_COPY_FUNCTION(TYPE, SUFFIX)               \
int copy_function_ ## SUFFIX(unsigned count, TYPE* arg) {   \
 /* do something with TYPE */                               \
 return whatever;                                           \
}

You may then use this to declare the functions in a header file

DECLARE_MY_COPY_FUNCTION(unsigned, toto);
DECLARE_MY_COPY_FUNCTION(double, hui);

and define them in a .c file:

DEFINE_MY_COPY_FUNCTION(unsigned, toto);
DEFINE_MY_COPY_FUNCTION(double, hui);

In this version as stated here you might get warnings on superfluous `;'. But you can get rid of them by adding dummy declarations in the macros like this

#define DEFINE_MY_COPY_FUNCTION(TYPE, SUFFIX)               \
int copy_function_ ## SUFFIX(unsigned count, TYPE* arg) {   \
 /* do something with TYPE */                               \
 return whatever;                                           \
}                                                           \
enum { dummy_enum_for_copy_function_ ## SUFFIX }