In C language, there are no native templates like those found in C++. Templates in C++ allow for generic programming, where functions or classes can operate with generic types. However, you can achieve a similar effect in C using techniques like macros and void pointers. Here are some basic concepts related to creating a template-like functionality in C:

1. Macros: You can use the C preprocessor to define macros that can act like templates. Macros allow you to define code that can be reused with different types by using placeholder syntax.

   #define SQUARE(x) ((x) * (x))  

   This macro can be used with any data type that supports multiplication.

2. Void Pointers: Another way to achieve type genericity in C is by using void pointers. This allows you to write functions that can accept pointers of any type.

   void swap(void* a, void* b, size_t size) {  
       char temp[size];  
       memcpy(temp, a, size);  
       memcpy(a, b, size);  
       memcpy(b, temp, size);  
   }  

   Here, swap can swap values of any type as long as the size is known and correctly passed.

3. Function Pointers and Callbacks: When dealing with operations that vary with type, function pointers can be used to pass different behaviors to the same function template.

   void sort(void* base, size_t nitems, size_t size, int (*compar)(const void*, const void*));  

   For sorting, C uses qsort which leverages function pointers for comparison.

4. Type-Specific Functions: While not generic in the template sense, writing type-specific functions and overloading them by names (using a consistent base name and suffix) can mimic template functionality.

   int sum_int(int a, int b) {  
       return a + b;  
   }  
   float sum_float(float a, float b) {  
       return a + b;  
   }  

5. Static Inline Functions (C99 and later): You can use static inline functions in headers for type safety and inlining, providing a more performant alternative to macros.

   static inline int max_int(int a, int b) {  
       return (a > b) ? a : b;  
   }  

While C lacks built-in support for templates, these techniques allow programmers to achieve a level of type generality comparable to templates in C++. However, they often come with trade-offs in safety and efficiency compared to C++ templates.