C中使用void *的C中的模板

Question

I have a generic class written in C++ and as an exercise, I've been attempting to port it to C. I've tried typedef to specific types but realized it was probably the wrong way to go about it. I'm attempting to use void pointers however i realized i have noway to instantiate the generic class is their something i am missing?

ctrie.h

#ifndef _COM_WORDGAME_UTILITY_TRIE_H_KYLE
#define _COM_WORDGAME_UTILITY_TRIE_H_KYLE
#ifdef __cplusplus
extern "C"{ //this is used to identify following code as C specific code which will enforce C style name mangling
#endif


typedef struct Trie Trie;

//Create new Trie Object
Trie* newTrie(void * defVal);
//return number of key-value pairs
int size(Trie * t);
//return default value set by user
void * getDefaultValue(Trie * t);
//Check if returned value is not equal to default value
bool contains(Trie * t,const char * key);
//Return Value
void * get(Trie * t,char * key);
//Insert String into symbol Table
void put(Trie * t,char * s,void * val);
//Find and return longest prefix of s in TST
char * longestPrefix(Trie * t,char * s);
//compress the table making it immutable returning the number of nodes removed
int compress(Trie * t);

#ifdef __cplusplus
#include "cTrie.cpp"//quick hack to add cTrie without linking
}
#endif
#endif

ctrie.cpp

#include "Trie.hpp" //C++ code
#include "Trie.h" //C code

extern "C"{
using namespace com::wordgame::utility::trie;

//Create new Trie Object
Trie* newTrie(void * defVal){
    return new Trie<typeid(defVal)>(defVal);    
};
//return number of key-value pairs
int size(Trie * t){}
//return default value set by user
void * getDefaultValue(Trie * t){}
//Check if returned value is not equal to default value
bool contains(Trie * t,const char * key){}
//Return Value
void * get(Trie * t,char * key){}
//Insert String into symbol Table
void put(Trie * t,char * s,void * val){}
//Find and return longest prefix of s in TST
char * longestPrefix(Trie * t,char * s){}
//compress the table making it immutable returning the number of nodes removed
int compress(Trie * t){}


}

Answer 1

One of the key advantages of templated container types in C++ is the ability to provide a nice syntactic way to embed the relevant object into the structure itself, so for example a typical std::vector<T> (which is typically implemented as a simple array) can have the stride of a T . To accomplish something like this in C, you would need to either implement your entire function as a bunch of macros, and then "Instantiate" the function set for each type, for example, a simple "Vector" implementation in C might look like this (which is either ugly, beautiful, or satanic depending on who you ask)

#define VECTORFUNCS(T) \
  typedef struct { \
    T* arr; \
    size_t narr; \
    size_t capacity; \
  } VECTOROF_##T; \
  \
  void vector_##T##_reserve(VECTOROF_##T *v, size_t n) { \
    // \
  } \
  const T* vector_##T##_at(VECTOROF_##T *v, size_t ix) { \
    return v->arr[ix]; \
  } \

VECTORFUNCS(int)
VECTORFUNCS(struct sockaddr)

// etc.

As a side note, this could also be implemented much more "cleanly" (depending on who you ask) by simply passing the sizeof(T) and using a single set of functions for any implementation; the functions would need to treat the arr element as a char* and properly determine the offsets for various operations).

However, if all your template class does is attach a pointer to T for type safety, you may do this entirely in C without much hassle, except of course that you don't get to "instantiate" the template each time (and is also not as necessary. C makes casting from void much less annoying).