C coding

garbage collection
https://github.com/mkirchner/gc

linked lists
http://www.codeofhonor.com/blog/avoiding-game-crashes-related-to-linked-lists and github code https://github.com/webcoyote/coho/blob/master/Base/List.h

resources
https://github.com/kozross/awesome-c

http://libcello.org/learn/a-fat-pointer-library fat pointers

pages
http://www.gamepipeline.org by Eskil Steenberg "How I program c" download code from http://www.quelsolaar.com/mergesource.zip

static code analysis

 * https://www.owasp.org/index.php/Source_Code_Analysis_Tools
 * https://en.wikipedia.org/wiki/Coverity
 * https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis

https://zeroturnaround.com/rebellabs/developers-guide-static-code-analysis-findbugs-checkstyle-pmd-coverity-sonarqube/2/

c2man code analysis
converts c code a man page.
 * http://nixdoc.net/man-pages/linux/man1/c2man.1.html
 * https://pastebin.com/4SGRvtRw Install script

Documentation

 * https://en.wikipedia.org/wiki/Comparison_of_documentation_generators

http://www.eclipse.org/downloads/packages/eclipse-ide-cc-linux-developers-includes-incubating-components/indigor

http://lttng.org/

Linux tools such as GCov, GProf, OProfile, and Valgrind. Visualization and analysis plugins for Linux tracing tools LTTng and SystemTap are also present https://en.wikipedia.org/wiki/List_of_performance_analysis_tools#C_and_C.2B.2B


 * https://en.wikipedia.org/wiki/Gcov, http://www.linux-mag.com/id/1409/
 * https://en.wikipedia.org/wiki/OProfile
 * https://en.wikipedia.org/wiki/SystemTap

https://en.wikipedia.org/wiki/List_of_performance_analysis_tools

https://en.wikipedia.org/wiki/Profiling_(computer_programming)

http://valgrind.org/

https://en.wikipedia.org/wiki/Splint_(programming_tool)

https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis#C.2C_C.2B.2B

https://en.wikipedia.org/wiki/Static_program_analysis

quora
https://www.quora.com/Why-is-C-and-C++-such-spectacular-examples-of-incompetence

https://www.quora.com/What-actually-happens-when-dereferencing-a-NULL-pointer-Usually-the-process-terminates-Does-the-reaction-depend-on-the-operating-system-or-is-it-controlled-by-the-compiler-Is-it-mandatory-that-NULL-always-be-defined-as-%E2%80%9C0%E2%80%9D-with-proper-casting/answer/Ferenc-Valenta

oop in c
http://www.planetpdf.com/codecuts/pdfs/ooc.pdf frm https://stackoverflow.com/questions/415452/object-orientation-in-c?rq=1

links
https://archive.ph/SsehB If you're talking standard, portable C++, then the answer is no, there are several things C does that C++ cannot do. C++ cannot declare same-type pointers to be non-aliasing. C does it with the keyword "restrict" (restrict type qualifier ), C++ compilers usually have non-portable ways to do the same, since it's a very important and irreplaceable language feature. C++ cannot allocate an array of runtime bound on the stack, see Array declaration . There is a proposal to add that to C++, especially since many compilers support such arrays as a non-portable extension, but it's been failing for various reasons. The workaround is the non-standard alloca, perhaps hidden in an allocator. C++ cannot initialize a struct if the order of its members is not known, cannot initialize a union to non-first variant, and cannot selectively initialize array elements, since it does not have C's designated initializers - see Struct and union initialization and Array initialization (the workaround is to initialize everything and then assign each member that needs a non-zero value, which is annoying whenever I have to deal with C APIs) I can think of a few others, which aren't that major, in my opinion:

C++ cannot form (and doesn't really need) anonymous objects with lvalue access, in C those are compound literals

C++ cannot select expressions based on the argument type. In C that is Generic selection -- C++ has overloading instead C++ has no pure imaginary numbers (although few C compilers implemented pure imaginary numbers): Arithmetic types (and in general, C's approach to floating-point numbers is far more robust than C++'s in several important ways). C++ approach seems to use libraries.

C++ doesn't have flexible array members: a C struct can have an array of arbitrary length as its last element (Struct declaration ), C++ doesn't really need that and it breaks the whole type-object-size relationship. C++ formally does not support type punning for unrelated types (C does, through unions), but most compilers define it for C++ as an extension

There also are dozens of valid C code constructs that are invalid C++ (or worse, valid C++ that does something different) - tentative definitions, implicit casts from void*, anonymous structs, static array indices, etc - I tried to focus on actual concepts that have no replacements. See Torvalds on C++.