1. encapsulation - hiding internal data from external access 2. opaque struct - a struct whose fields are hidden from other files 3. module interface - the public functions that other files can call 4. module implementation - the private code kept inside the c file 5. data hiding - preventing direct access to internal fields 6. abstraction - exposing only essential operations 7. private state - data stored inside a struct that callers cannot see 8. public api - the set of functions exposed in the header 9. static function - a function limited to the current c file 10. forward declaration - announcing a struct without revealing its fields 11. opaque pointer - a pointer to a hidden struct 12. getter function - a function that returns internal data safely 13. setter function - a function that updates internal data safely 14. controlled access - restricting how callers interact with data 15. encapsulated object - a struct managed only through functions 16. implementation detail - code hidden from external modules 17. interface boundary - the separation between public and private code 18. hidden fields - struct members not visible to other files 19. safe modification - updating data only through defined functions 20. invariants - rules that internal data must always follow 21. api contract - the behavior guaranteed by public functions 22. private helper - a static function used only inside the module 23. opaque type - a type whose structure is not exposed 24. information hiding - keeping internal logic invisible 25. modular design - organizing code into separate encapsulated units
26. separation of concerns - dividing responsibilities across modules 27. encapsulated module - a c file that hides its internal data 28. controlled creation - allocating objects only through create functions 29. controlled destruction - freeing objects only through destroy functions 30. hidden memory layout - keeping struct layout private 31. safe interface - a set of functions that prevent misuse 32. restricted visibility - limiting what other files can see 33. private allocation - memory allocated inside the module only 34. private deallocation - memory freed inside the module only 35. opaque handle - a pointer used to reference a hidden object 36. encapsulated state - internal values protected from external access 37. api surface - the set of visible functions in the header 38. internal logic - code that stays inside the c file 39. hidden implementation - details not exposed to callers 40. controlled behavior - actions defined only through public functions 41. private struct - a struct defined only in the c file 42. public header - the file that exposes the interface 43. hidden header content - definitions intentionally omitted from the header 44. safe abstraction - exposing behavior without exposing data 45. encapsulated design - structuring code to hide internals 46. opaque design - using hidden structs to protect data 47. interface function - a function that provides controlled access 48. private variable - a variable not visible outside the module 49. encapsulated resource - a resource managed only through module functions 50. hidden pointer target - a pointer whose underlying struct is private 51. controlled struct access - interacting with a struct only through functions
>coding stuff>OP is troonStereotypes for a reason, I guess.
>>85579841most languages handle encapsulation automatically (working with multiple files) but c is unique since it gives you the tools to do most things other languages do but you have to engineer the encapsulation yourself manually in every projectwhich i think is nice since most languages you do have to understand encapsulation while not actually building with it which is dumb since the actual typing to build it is not much and the savings of having clear code is very big
