Klib VS STC

If you want a generic, extremely high performance implementation. I really recommend khash: https://github.com/attractivechaos/klib/blob/master/khashl.h

Most importantly, sqzlib is fully compatible with klib/kseq.h one of the highest performance fastA/Q parsers. This means that any application that uses kseq.h for fastA/Q parsing, can be easily modified to use sqzlib instead. You can find patched versions of seqstats, minimap2, and bwa-mem2 in my github, or you can patch them yourself with the included patches.

I don;t know if you are aware of khash? It's a very nifty hash table implementation. It is one of the fastest hash table implementations out there. Heavily used in bioinformatics. You said in your post that you are a macro guy, well, you are in for a treat with this library.

This is in fact a pretty common pattern in production code.

Here's an entire suit of type safe generic data structures in C: https://github.com/attractivechaos/klib

You will probably want to invest some time into either finding a good data structures library (preferable) or writing your own data structures (fine to do but not a good use of your time if you're starting out). You can try SGLIB or klib.

u/attractivechaos: I relate this to my own STC container library, which is a "true" templated library. When specifying a raw pointer as value type for the hashmap, and no value destructor, it behaves like a non-owning container. The user therefore manage the pointed-to data elements (or "nodes"), and can apply the "trick" you mention, so there is no memory size advantage for the intrusive map over a hashmap in this regard.

But the most common that I know of is this one: https://github.com/tylov/STC. There's also this one mentioned above https://rurban.github.io/ctl/

To illustrate, using a generic typesafe container lib, like my own STC, it is just as simple to write this in C. Also uses RAII (c_auto macro). cvec is templated, here using the lib's string type, so cvec_str is already pre-configured, but containers can use any custom elements type-safely:

sfc64 is about the same speed as sfc32, so almost twice as fast per bit generated on most 64-bit platforms. I have a slightly modified version in my STC library which is equally fast, but supports threads/streams, similar to PCG. The lack of streams or jump function is one of the few criticisms to sfc. In my mind it is merely a theoretical limitation, as the chance for repeating subsequence are incredible small, but if you need that assurance, my variant can be interesting as it is quite a bit faster than e.g. xoshiro and not sensitive to "bad" seeds.

The background for the question is that many C programmers swears to use intrusive containers as the superior alternative to STL-style containers. I have a templated C container library in STL style (compiles in C++, works with standard layout types only), and have argued that for most cases, traditional STL-style containers are more natural and easier to manage. But I believe there are situations where intrusive containers are better.

I didn't intend to mention my own templated STC container library, but I am confident that it is superior to any intrusive or other generic container C libraries for that matter. That's a bold statement, but I'll be happy to compare anything from usability (API), memory usage, speed or library footprint with any other container lib, intrusive or not.

FYI. You can write this portable, more robustly with my STC library with less lines, but it takes some effort to understand the workings of a library too. Note that the non-portable POSIX getline() includes the newline char in the line (seldom desirable). cstr_getline() does not. c_autovar is an optional convenience macro, you can use ..init() and then ..drop() at end of function instead.

Just remember, if you choose C and you need to use the basic containers that C++ includes in its standard library like vectors and maps, use this library, it will make your life so much easier!