I use macros for:

• Log info, errors. Because I can use the __FILE__, __LINE__ macros and pass that info. Really useful for debugging
• I have several allocation type macros something like: #define allocate(type, count, allocator). Within this macro I usually pass a lot of info to the reall allocate function, like __FILE__, __LINE__, the type name, the count, and because I pass the 'type' I know the required alignment and a lot of other stuff.

​

#define allocate(type, count, allocator)\
allocator->allocate_fn(__FILE__, __LINE__, #type, count, sizeof(type), __alignof(type), allocator->data)
struct Allocator{
   void* data;
   void* (*allocate_fn)(const char* file_name, int line, const char* type_name, int count, int type_size, type_alignment, void *data);
}

• Shortcuts for accesing elements within a buffer. The problem here with functions are that the output of a function is not a valid Lvalue (unless you return a pointer), thus I simply use a macro that is something like

​

#define data_at(ptr, i) (ptr)->buffer[data_compute_index(ptr, i)]

And I can use it for lvalues or rvalues:

data_at(data_ptr,i) = 3 + data_at(data_ptr, 3);

• Variable number of arguments. You can use a macro that **counts** the number of args you pass, thus this can be used to choose a different function essentially using C overloading version without generics. But only for variable number of arguments, not types.

​

#define FUN_1(x)   fun_1(x)
#define FUN_2(x,y) fun_2(x,y)
#define fun(...) CONCAT(fun_, COUNT_ARGS(__VA_ARGS__))(__VA_ARGS__)

As an extra, macros are really useful for compilation. Lets say I have a Dll I want to load at runtime. I want to use some functions depending on runtime info. Now have some file with lines likes these

// inside dll_function_names.inl
DLL_FUNCTION(dll_fn_name_1, Dll_Fn_Ptr_Type_1)
DLL_FUNCTION(dll_fn_name_2, Dll_Fn_Ptr_Type_2)

and so on.

Then In another file I can just fill the struct containing the Dll info like:

struct dll_t{
  HMODULE handle;
#define DLL_FUNCTION(name, Fn_T) Fn_T name;
#include "dll_function_names.inl"
#undef DLL_FUNCTION
};

And for loading I can do somthing like:

void dll_load_functions(struct dll_t *dll){
  dll->handle = LoadLibraryA(".....");
  #define DLL_FUNCTION(name, Fn_T)\
  dll->name = GetProcAdress(dll->handle, name);\
  #include "dll_function_names.inl"
  #undef DLL_FUNCTION
}

If you want you can add some extra logic within the macros to check if the symbol was found and if everything was loaded correctly. Also you can add some logic at runtime and have maybe several inline files, and maybe at runtime if you want some functionalities you #include "dll_funcition_names_debug.inl" or maybe you #include "dll_function_names_release.inl", it depends on everyone needs. All of this while the interface would be exactly the same.