Implementing Generic Types in C

https://btmc.substack.com/p/implementing-generic-types-in-c

89 45 1 year ago

btmc.substack.com

For C with generic types, I think one should pick up Zig. It's exactly that, it's a low level language with manual memory management, but it allows you to do generic types like this without hacks.

randomNumber7• 1 year ago

You could use C++ and ignore the rest of it.

huhtenberg2• 1 year ago

Not sure why the parent is in gray. It's a perfectly valid and widely practiced approach.

bfrog• 1 year ago

I tried it once, ran out of memory debugging a template error as it blew up my terminal into a sea of jibberish.

unclad5968• 1 year ago

C3 and Odin are some other alternatives.

jdougan• 1 year ago

Along with D

alcover2• 1 year ago

I often see such replies and wonder : the article isn't about choosing langs but is an exercise in C. That's the constraint.

bsder2• 1 year ago

If C is the constraint, then why are you doing generic types?

If you're using C, use bloody C. Not C with weird extensions that nobody will understand. Not C attempting to gussy up into a language with a real type system. Not C with a garbage collector. etc.

I don't get why so many people use C but don't want C. This isn't 1995 where you have to shoehorn everything into the C ecosystem because everything else sucked.

sirwhinesalot2• 1 year ago

Zig is nice. Comptime is a really cool feature.

dleslie• 1 year ago

I've never heard of CC before; the ergonomics of it look positively _modern_.

https://github.com/JacksonAllan/CC

juancn• 1 year ago

The Java example doesn't really compile due to generic arrays and mixing primitives and non-primitives, but the point still holds.

Type erasure is still type checked though, it's just lost at runtime (i.e. the generics are not reified).

This works for Java very well because the JIT will have another chance at further optimizations once the application runs.

alcover2• 1 year ago

Type erasure is still type checked though

In the C example ? What do you mean ?

to11mtm2• 1 year ago

If I had to guess, they were moreso referring to the java examples... The article states "The biggest issue is the same one Java had before version 5, there’s no type safety"...

But that's a weird way to put it... Java 5 was when generics were actually introduced... so comparing a C hack for generics to Java pre V5... is just... weird.

huhtenberg2• 1 year ago

I personally quite enjoy programming in “C with methods, templates, namespaces and overloading”, avoiding the more complicated elements of C++ (like move semantics2)

Don't we all.

Except for the committee, of course, and its entourage.

marcodiego• 1 year ago

https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3509.pdf

hgs32• 1 year ago

Is this the version of "generics" the C committee is leaning towards? Last I checked there were at least three other proposals [1] [2] [3].

[1] https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3212.pdf

[2] https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2924.pdf

[3] https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2853.pdf

spacedcowboy5• 1 year ago

Probably worth mentioning the C Template Library [1]...

[1] https://github.com/glouw/ctl/

dsp_person• 1 year ago

I've found useful doing an implementation with void* and having thin macros to do casting with typeof() so the usage is type checked.

jll29• 1 year ago

The former is nicer to program while the latter is nicer to use.

When I have such a situation, I'm inclined to write myself my own pre-processor (as I did for Pascal once in a previous millenium, on an Atari ST 520+), so that you can write in a style that is nicer to program in, which gets pre-compiled into something that is nicer to use from your client code.

Nothing comes without downsides: the price of this is that other developers need to understand your idiosyncratic pre-processor, so this method works best for "single author" code/personal projects.

What you don't want in a team is each coder having their own way of doing things, so that you cannot share libraries and helper functions.

BTW, the best book on the OP's topic of production coding in C and implementing type-safe ADTs is Chris Hanson's book "C: Interfaces and Implementations." It contains some eye-opening tricks even for experienced developers in (standard) C.

RossBencina• 1 year ago

I wonder are there any existing metaprogramming frameworks for C? (something like C#'s Roslyn) I've been playing around with ANTLR and Python but curious to know what I've missed.

usrnm2• 1 year ago

C++. Only half-joking, this is exactly how C++ started

hgs32• 1 year ago

It's worth mentioning that there are dedicated processors, like m4, and templating engines, like Jinja, if you need something battle-tested.

WalterBright• 1 year ago

When moving into generic types and metaprogramming in C, your only real choice is macros. I've been down that path. It just never seems to work out very well, and the results were always unsatisfying.

At some point, it becomes worthwhile to graduate to a more powerful language that still retains all the low level capability, like DasBetterC.

tidwall• 1 year ago

Here's a b-tree library I wrote that uses a similar approach. https://github.com/tidwall/bgen

cyber1• 1 year ago

Unfortunately, the standardization committee plays around with macros and _Generic instead of investing their time in modern metaprogramming ideas

codr73• 1 year ago

This is how I do proper generic vectors in C, no template tricks needed and no pointer chasing involved:

https://github.com/codr7/hacktical-c/tree/main/vector

The problem was always pretending C is something it's not, that never works well in any language.

wolfspaw• 1 year ago

Lol, thats insane.

And awesome, I love it!

attractivechaos• 1 year ago

For linked lists and binary trees, intrusive data structures are better.

Well, except the first one, template macros, where I can’t really find any pro, only cons.

For toy examples, the first (expanding a huge macro) has mostly cons. But it is more flexible when you want to instantiate different parts of the header. The second approach can work but will be clumsy in this case because the whole header is considered as one unit.

Implementing Generic Types in C

Related Stories