C coding

=== garbage collection ===
mkirchner
=== 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
=== scope ===
https://publications.gbdirect.co.uk//c_book/chapter8/declarations_and_definitions.html 
------------------
https://stackoverflow.com/questions/7059800/why-do-structure-definitions-have-internal-linkage 
https://stackoverflow.com/questions/6316987/should-struct-definitions-go-in-h-or-c-file?rq=1 which refs https://en.wikipedia.org/wiki/Opaque_pointer 
https://stackoverflow.com/questions/330793/how-to-initialize-a-struct-in-accordance-with-c-programming-language-standards?rq=1 
https://stackoverflow.com/questions/4136888/declaring-a-struct-in-h-file-and-implementing-in-c-file?noredirect=1&lq=1 
https://stackoverflow.com/questions/64315674/recognising-structs-inside-header-files-in-c?noredirect=1&lq=1 
=== resources ===
https://github.com/kozross/awesome-c 
http://libcello.org/learn/a-fat-pointer-library fat pointers 
https://www.raspberrypi.org/blog/an-introduction-to-c-gui-programming-the-new-book-from-raspberry-pi-press/ from https://github.com/epccs/GtkExample (Arduino irrigation). 
https://codeyarns.com/2017/11/02/how-shared-library-locations-are-found-at-runtime/ 
https://codeyarns.com/2014/01/14/how-to-add-library-directory-to-ldconfig-cache/ /etc/ld.so.conf as sudo and add a new line with the library directory. In this case, we add /opt/foobar/lib. 
http://man7.org/conf/lca2006/shared_libraries/index.html 
https://codeyarns.com/2013/12/24/how-to-set-c-or-c-compiler-for-cmake/ 
Nvidia cuda blade install 
=== book reviews ===
https://www.embedded.com/c-for-everyone/ C for Everyone , by Richard Man and CJ Willrich, is a new 400 page book covering the C language, with an emphasis on using it in embedded systems. I
=== github ===
https://github.com/a-p-jo Collection of C99 dynamic array implementations . Generic C99 Singly & Doubly Linked List Implementation with OOP, ranges, custom loops and more. CLIp is a clipboard manager for a command line interface written in 100% standard C only. Pipe to it to copy, pipe from it to paste. 
https://github.com/MomentsInGraphics/vulkan_renderer from https://momentsingraphics.de/ToyRendererOverview.html 
https://github.com/o3de/o3de gaming engine procedural based without stuffing the struct see https://news.ycombinator.com/item?id=27751358
https://github.com/godotengine/godot gaming engine procedural based, but stuffing the struct.
https://godotengine.org/article/why-isnt-godot-ecs-based-game-engine
ECS is a design pattern commonly used in video games (although not very often used in the rest of the software industry) which consists of having a base Entity (a container object) and Components that can be added upon it. Components provide data and the means to interact with the whole world. Finally, Systems work independently and do actions on every similar component.
This design became common in game engines and libraries in the early 2010s. The main appeal (besides architecture) is the fact that component data can be placed in contiguous memory, improving cache access. This is a common form of data-oriented optimization.
Architecturally wise, ECS aims to replace inheritance, by favouring composition, similar to how interfaces or multiple inheritance works in OOP. The key advantage in ECS is that components are dynamic (can be added or removed in run-time).
=== gists ===
https://gist.github.com/Gerjo/3939313 Simple program to demonstrate a couple uses for pointers. This program was
written so I could learn more about how to apply pointers and their syntax. 
https://gist.github.com/mrnugget/6208844 cheat sheet https://denniskubes.com/2017/01/24/the-5-minute-guide-to-c-pointers/ 
https://denniskubes.com/2012/08/19/pointers-and-arrays-in-c/
https://denniskubes.com/2013/03/22/basics-of-function-pointers-in-c/ see https://www.youtube.com/watch?v=axngwDJ79GY with https://pastebin.com/rirpBxGU function pointers. Ref Oop in c
https://gist.github.com/emekoi/a97f6009fba45a0facb070ee4448b5f3 arrays 
=== 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/Is-it-a-good-idea-to-typedef-pointers-to-the-functions or https://archive.ph/wip/nde5v 
https://code.quora.com/Object-Oriented-Programming-in-C-A-Deep-Dive 
https://www.quora.com/Why-is-C-and-C++-such-spectacular-examples-of-incompetence 
dereference null pointer 
https://www.quora.com/If-Linus-Torvalds-doesnt-like-C-at-all-why-is-some-of-the-Linux-Kernel-written-in-it 
=== oop in c ===
http://www.planetpdf.com/codecuts/pdfs/ooc.pdf frm https://stackoverflow.com/questions/415452/object-orientation-in-c?rq=1
=== youtube ===
https://www.youtube.com/watch?v=u1e0gLoz1SU header files by https://www.youtube.com/@CodeVault 
https://www.youtube.com/watch?v=NeOTr0u7ALk header files, extern from @JacobSorber 
https://www.youtube.com/watch?v=qqtmtuedaBM Kris Jordan 
https://www.youtube.com/watch?v=KJgsSFOSQv0&list=PLWKjhJtqVAbmUE5IqyfGYEYjrZBYzaT4m freecodecamp several hour playlist 
https://www.youtube.com/watch?v=xLetJpcjHS0&list=PLBlnK6fEyqRj9lld8sWIUNwlKfdUoPd1Y nesoacademy 141 vids 
https://www.youtube.com/watch?v=CpjVucvAc3g&list=PL2_aWCzGMAwLZp6LMUKI3cc7pgGsasm2_&index=7 codeschool pointers in c. 
https://www.youtube.com/watch?v=ec-Cd4jKFWc&list=PLxCzCOWd7aiGmiGl_DOuRMJYG8tOVuapB gatesmashers 47 vids 
https://www.youtube.com/watch?v=2ybLD6_2gKM One of the hardest things for new programmers to learn is pointers. Whether its single use pointers, pointers to other pointers, pointers to structures, something about the concept drives new programmers crazy. The C programming languages is recognized as one of the most difficult programming languages to learn. The reason for this is the limitless power you have over memory management, which comes from pointers. In this video, I show you what a pointer is, as it applies to low level memory access. Also, we talk about pointer syntax in C and how you can better understand the pointer syntax by converting it to English. And we wrap the video up by asking "why do we care?". 
https://www.youtube.com/watch?v=YzBgXpwm02w malware 
=== reddit ===
https://www.reddit.com/r/arduino/comments/2tyagj/structs_and_progmem/ 
https://github.com/astelios/bear_ascii_animation/tree/main file inclusion from https://www.reddit.com/r/C_Programming/comments/1dfd1de/bear_ascii_art_in_c/?chainedPosts=t3_3al544 
=== links ===
https://faultlore.com/blah/c-isnt-a-language/ ABI breaking 
https://blog.dave.tf/post/finding-bottom-turtle/ web to trust with compilers , "....As I said above, right now Mes is the bottom turtle. The state of the art bootstrapping chain ends with “a miraculous set of binaries for the Mes Scheme interpreter exist”. That’s a smaller chunk of miraculous code, but it’s still 60 million bytes of stuff, far too much for a human to inspect and validate by hand..." , refs http://bootstrappable.org/best-practices.html see https://github.com/dt-zero/me_cleaner intel management engine has root access network everything , https://www.coreboot.org/ See Quantum mechanics 
https://cdecl.org/ c gibberish to english 
https://archive.ph/jGPed why not replace c with Cpp? 
https://www.reddit.com/r/C_Programming/comments/3al544/damien_katz_the_unreasonable_effectiveness_of_c/ see https://archive.ph/RfIeK for archive of article 
Oop in c 
vlang, rust 
https://makefiletutorial.com/ 
https://c-faq.com/ 
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++. 
michael barr 
Category:Coding
Category:Linux
Category:C coding