HAhal9000xp·Oct 15, 2017
I've been pure C developer for 5+ years (worked with codebase of ~2.5 million lines of code) and I took a quick look (just out of curiosity) at the content and one thing immediately strikes me:
http://cs.yale.edu/homes/aspnes/classes/223/notes.html#What....
7.1 What's wrong with C
a) C doesn't have a garbage collector
Disagree that's it's wrong. If you code is well structured, then it's no big problem to avoid memory leaks. On top of that, you can use RAII if you are willing to use C-extensions like this one:
https://lwn.net/Articles/589433/
Garbage collector just helps you to write semi-workable messy code (a dream of industrial developers).
b) C doesn't support any kind of polymorphism
If you use type cast in well structured code, it's no big problem.
c) C doesn't have exceptions
This may be a bit tricky but you still can use exceptions
Read the rest
in C using longjmp/setjmp:
http://www.di.unipi.it/~nids/docs/longjump_try_trow_catch.ht...
Although __cleanup__ extension doesn't work in this case.
It's worth to take a look at this stack unwinding library:
http://www.nongnu.org/libunwind/
Quote:
With libunwind, it is possible to implement an extremely efficient version of setjmp(). Effectively, the only context that needs to be saved consists of the stack-pointer(s).
In general, if you look at C as a high level assembler and willing to write or use existing low-level framework for "meta-language" primitives (like pointer virtualization), then you can write nice programs in your "meta-language".
For example, I wrote some project for fun using pure C with bare minimum libraries. And I needed to make sure that I could detect the following bug as soon as possible:
1. Object X is created and owned by some code OWNER_X;
2. Pointer to this object X is passed to some code USER_OF_X;
3. Object X is freed in OWNER_X;
4. New object Y is created in OWNER_X which happens to have the same address as recently freed object X;
5. Because of some bug USER_OF_X still uses pointer to object X;
I wanted USER_OF_X to fail on asserts as soon as possible if this happens. It would be hasty bug and hard to detect in unprepared code if X and Y happens to be the same type. When people are saying that it's nearly impossible to detect such bugs in C, they just don't consider using framework which cleverly detects this issue.
By the way, this is my implementation pointer virtualization which helps to detect this sorts of bugs:
https://github.com/hal9000xp/euclid/blob/master/core/main.h
Look at PTRID.
https://github.com/hal9000xp/euclid/blob/master/core/linked_...
Look at usage of PTRID in LL_CHECK
This is how I use them together:
https://github.com/hal9000xp/euclid/blob/master/core/network...