The C²++ Programming Language

# The C²++ Programming Language **A Reconstructed Language Guide: Reference, Developer Notes & Educational Material** > #### A didactic all Paradigm Language > *Eine didaktische Programmiersprache für alle Paradigmen* > > --- > > #### Rethinking Programming from scratch > *Programmierung von Grund auf neu denken* > > --- > > #### Self-definition is the best way to reuse > *Eigen Definition ist der beste Weg zur Wiederverwendung* https://hackmd.io/KNK6ELGWQ0yJxvkQNCmDvQ > This Document isn't: > - a Reference Manual > - a Developer Guide > - a Design History Summary > It's all of them mixed. > Zur besseren Orientierung folgen alle Beispiele und Erklärungen einem einfachen System: - 🔷 **Beispiele** — echte Codebeispiele mit konkreter * C²++ core0 Syntax * *(z. B. `type`, `namespace`, `async<<T>>`, "`: pop _ 0x020 push : func()`" … )* * C²++ Syntax * *(z. B. `class`, `interface`, `feature`, `view` … )* - 🔶 **Erklärungen** — begleitende theoretische Abschnitte *(Hintergründe, Vergleiche, Motivation, semantische Unterschiede)* ## Concepts - [📋 C²++ Names: Keywords, Protected Words, Identifier](https://hackmd.io/@UPTOIP/ryzX1tAXWl) - [🏷️ C²++ Versions, Tags and Type-Accessor](https://hackmd.io/@UPTOIP/r1kIsiA7Wl) - [🔑 C²++ Types Concepts and Overview](https://hackmd.io/@UPTOIP/HyAGUD14Wx) - [🪄 C²++ Axis as Concept](https://hackmd.io/@UPTOIP/SyG4Ndv0lx) - [🪄 C²++ Axis Semantics and Syntax](https://hackmd.io/@UPTOIP/HywLvaH0le) - [🌱 C²++ Class Inheritance](/Bj7Bk8uATKqckCSy9RIP0w) - [🌱 C²++ Class Refinement](/DibvwtYISMygHM4FFv4cIw) - Composites - Mixin - Trait - Aspect - Feature - Template Part (Template/CRTP) - builder - class Generator - [📰 C²++ Structures in comparison & differentiation](https://hackmd.io/@UPTOIP/rJfRfoMXZl) - [📑 C²++ Trennung Objekt/Methoden und Datenrepräsentation](https://hackmd.io/@UPTOIP/r1jzqwH4-g) ## The Object-World - [⭐ C²++ Object Welten](https://hackmd.io/@UPTOIP/SJQ8MrXSZl) - [⭐ C²++ `subject`/`object`-Dualismus](/WXpdjWlyTjy3IdSOG3YaLw) - [🌱 C²++ Atomic Inheritance Axis](https://hackmd.io/@UPTOIP/SJN6ofeIWl) - [🌱 C²++ Class Inheritance](/Bj7Bk8uATKqckCSy9RIP0w) - [🌱 C²++ Class Refinement](/DibvwtYISMygHM4FFv4cIw) - [✔ C²++ `object` 1](https://hackmd.io/@UPTOIP/Skj3aYtbbx) - [✔ C²++ `object` 2](https://hackmd.io/@UPTOIP/HJSOcnK-bg) - [✔ C²++ `object` Model 1 - Smalltalk](https://hackmd.io/@UPTOIP/HkCeb-tbbg) - [✔ C²++ `object` Model 2 - Self](https://hackmd.io/@UPTOIP/S1lxa67rbl) - [✔ C²++ `object` Model 3 - Self](https://hackmd.io/@UPTOIP/Byc3gngfbe) - [✔ C²++ `object` Model 4 - JavaScript] - [✔ C²++ `object` Lexical Structural Typing](https://hackmd.io/@UPTOIP/Hk9Lo3IWWl) - [✔ C²++ `object` Bridge to `class`](https://hackmd.io/@UPTOIP/H18spHtbZe) - [🧩 C²++ Dispatch Object](https://hackmd.io/@UPTOIP/Sy0EYXTAeg) - Polymorphy: by Objects - Polymorphy: by DuckTyping - [📦 C²++ `class` 1] - [📦 C²++ `class` Model 1 - C++] - [📦 C²++ `class` Model 2 - Java] - [📦 C²++ `class` Model 3 - C#] - [📦 C²++ const Constructors](https://hackmd.io/@UPTOIP/BJ0jFBWkWl) - [📦 C²++ omission Constructors](https://hackmd.io/@UPTOIP/BykU6fHB-e) - [📦 C²++ Inline Direct Constructors](https://hackmd.io/@UPTOIP/r1Vw3iFagl) - [📦 C²++ Convention over Configuration](https://hackmd.io/@UPTOIP/H1fmlhYplx) - [C²++ `partial class` 2](https://hackmd.io/@UPTOIP/Sk0RcGSrZe) - [📦 C²++ Virtuelle Methoden Tabelle](https://hackmd.io/@UPTOIP/rJTtjtBrZl) - [📦 C²++ Dynamische Methoden Tabelle](https://hackmd.io/@UPTOIP/S1xCM3BBZl) - [🪟 C²++ Views 1](https://hackmd.io/@UPTOIP/ryuAqk02ex) - [C²++ Sealed Interfaces](https://hackmd.io/@UPTOIP/Hkg2y0Tz-e) - [⭐ C²++ `subject`](https://hackmd.io/@UPTOIP/r1Kis1HQZx) - ⭐ C²++ `subject` Model 1 - Haskell - [⭐ C²++ `subject` Model 2 - Haskell](https://hackmd.io/@UPTOIP/H1EvYHrQWx) - ⭐ C²++ `subject` Model 3 - Scala - ⭐ C²++ `subject` Model 4 - F# - [📑 C²++ `record`/`subject` Trennung Repräsentation/Implementation](https://hackmd.io/@UPTOIP/r1jzqwH4-g) - [📒 C²++ HowTo Define a Qualifier - example `volatile`](https://hackmd.io/@UPTOIP/HJTdb5FV-g) - Polymorphy: by restricted Ad-Hoc Lookup - Polymorphy: by cumulative Ad-Hoc Lookup ## General - [⬛ C²++ CompileTime vs RunTime](https://hackmd.io/@UPTOIP/BJ7XfblXZe) - [⬛ C²++ CompileTime Stages](https://hackmd.io/@UPTOIP/BkDqDMxmbx) - [🟨 C²++ — Modul Include 1](https://hackmd.io/@UPTOIP/B1lLOpfheg) - [🟨 C²++ — Modul Include 2 - Linkage](https://hackmd.io/@UPTOIP/ByokQUx7bg) - [🟨 C²++ — Modul Import 1](https://hackmd.io/@UPTOIP/rJOcLu6GZe) - [🟨 C²++ — Modul Import 2 - compare](https://hackmd.io/@UPTOIP/r1zQs1wM-l) - [🟨 Das Modul-System von C²++ core2](https://hackmd.io/@UPTOIP/Hks20AfMWe) - [⬜ C²++ Language Infrastructure: include](https://hackmd.io/@UPTOIP/BymzZOgQZl) - [✨ C²++ core0 vs core2](https://hackmd.io/@UPTOIP/BJGZFpEJWl) - [🕳️ C²++ Profiles 1](https://hackmd.io/@UPTOIP/S1nFuaqRlg) - [🕳️ C²++ Profiles 2](https://hackmd.io/@UPTOIP/SJ8Q18Nkbl) - [🕳️ C²++ Profiles 3](https://hackmd.io/@UPTOIP/B15DK9IyWe) - [🕳️ C²++ Profiles 4](https://hackmd.io/@UPTOIP/BkwH6qIJZe) - 🕳️ C²++ Profiles 3 - core0 - 🕳️ C²++ Profiles 4 - core2 - [ **∷**   C²++ Namespaces 1](https://hackmd.io/@UPTOIP/SysTtEV0ge) - [ **∷**   C²++ Namespaces 2](https://hackmd.io/@UPTOIP/BkS7kP56xl) - [ **∷**   C²++ Namespaces 3](https://hackmd.io/@UPTOIP/B1VfbPQJZg) - [C²++ Orphan Rule 1](https://hackmd.io/@UPTOIP/SyY8S0pG-l) - [C²++ Orphan Rule X](https://hackmd.io/@UPTOIP/B1ZCXAafbe) - [ **∷**   C²++ Namespaces 4 - Qualifier] - [C²++ Effect Domains 1](https://hackmd.io/@UPTOIP/rJwu92r7Wx) - [ **∷**   C²++ Namespaces 5 - anonymous](https://hackmd.io/@UPTOIP/r1RLzqhfZx) - [ **∷**   C²++ Namespaces 6 - overlays] - [ **∷**   C²++ Namespaces 7 - Versions & Tags] - [ **∷**   C²++ Namespace Axis **`: load`**](https://hackmd.io/@UPTOIP/ByveooH0xg) - `: genesis` -- abgesicherter Stapel aller Erweiterungen - `: load` -- wird beim erstmaligem laden des Namespaces ausgeführt - `: area` -- bestätigt einen ns area - `: token` -- sichert einen Namensraum vor unberechtigter Erweiterung -  **∷**   C²++ Namespaces - prefixes -  **∷**   C²++ Namespaces - delegation -  **∷**   C²++ Namespaces - sealed - [🟦 C²++ — Alias](https://hackmd.io/@UPTOIP/S1lmjddGZx) - [🔓 C²++ Function Aliases](https://hackmd.io/@UPTOIP/Bk5vmkkAex) - [🗝 C²++ Type Definitons 0](https://hackmd.io/@UPTOIP/S17n0RjTge) - [🗝 C²++ Type Axis **`: typedefs`**] - : alias -- nur alias auf Basistypen B - : extends -- neuer type auf Basistypen B - : meta -- bindet eine Meta Class an Basistypen B (nur mit : extends) - [🗝 C²++ Type Axis **`: subtypes`**] - : based -- Basistypen B - : limits -- Einschränkung des Wertebereichs des Basistypen B - : restricts -- Einschränkung des Basistypen B Ausdrucksbasiert - [🗝 C²++ Type Axis **`: constraints`**] - : implements -- T, B implementiert Class - : supports -- T, B unterstützt Interface - [🗝 C²++ Type Axis **`: selection`**] - : switch -- Pattern-Match Auswahl der Typbildung - [🗝 C²++ Type Axis **`: aspects`**] - : adapts -- feature or aspect - : binds -- to class or interface - [🔑 C²++ Type Definitons 1](https://hackmd.io/@UPTOIP/HkbyE0jael) - [🔑 C²++ Type Definitons 2](https://hackmd.io/@UPTOIP/SyxqgpJnagl) - [🔑 C²++ Type Constraint Definitons 1](https://hackmd.io/@UPTOIP/BykCk1rRgl) - [🔑 C²++ Type Definitons 3](https://hackmd.io/@UPTOIP/BJPQUynTll) - 🔑 C²++ Type Selection Definitons 1 - 🔑 C²++ Type Definitons 4 - [🔑 C²++ SubType Definitons 1](https://hackmd.io/@UPTOIP/S1RkoY1Rex) - 🔑 C²++ SubType Definitons 2 - 🔑 C²++ incomplete Type Definitons 1 - [💫 C²++ Type Access](https://hackmd.io/@UPTOIP/r1yJqTuRgl) - [💫 C²++ Type Functions / Type Accessors](https://hackmd.io/@UPTOIP/S1xa72uRgg) - C²++ Dependent Types - [🔐 C²++ Dependent Types 1](https://hackmd.io/@UPTOIP/BkI9YBgRex) - [🔐 C²++ Dependent Types 2](https://) - [🔰 C²++ Dependent Checks](https://hackmd.io/@UPTOIP/ByWIQLxAeg) - [ **..**   C²++ Range Definitons 0](https://hackmd.io/@UPTOIP/HyvgcFkCge) - [♎ C²++ Final] - [♎ C²++ Const] - [♎ C²++ Var Typeinference] - [♊ C²++ Variables] - [C²++ Object Initializer](https://hackmd.io/@UPTOIP/rJImaRbzZx) - [C²++ Anonymous Types vs. Objects](https://hackmd.io/@UPTOIP/B11ANi4fbg) - [💾 C²++ storage classes: auto, register, static & heap](https://hackmd.io/@UPTOIP/SyiNewragx) - [♻️ C²++ Memory Allocator & Collector 1](https://hackmd.io/@UPTOIP/HJVyIVuhgx) - [♻️ C²++ Memory Allocator & Collector 2](https://hackmd.io/@UPTOIP/ryLKRGWS-g) - [♻️ C²++ Memory Allocator & Collector 3](https://hackmd.io/@UPTOIP/By6i0z-B-e) - [♻️ C²++ Memory Allocator & Collector 4](https://hackmd.io/@UPTOIP/H1Ocl-zG-x) - ♻️ C²++ Allocatoren, Collectoren - ♻️ C²++ Memory Allocator 1 - ♻️ C²++ Memory Allocator 2 - ♻️ C²++ Memory Collector 1 - ♻️ C²++ Memory Collector 2 - ♻️ C²++ Memory Collector 3 - [♻️ C²++ Partielle Allocatoren](https://hackmd.io/@UPTOIP/SkfgB8rrZe) - ♻️ MemStorage - ♻️ MemPool - ♻️ MemResist - [🧩 C²++-Typsystem Memory Models 0](https://hackmd.io/@UPTOIP/H184mj0z-l) - [🧩 C²++-Typsystem Memory Models 1 - `T` `T~`](https://hackmd.io/@UPTOIP/ryKC6lAzbe) - 🔄 C²++ DMAC (...) - [🔹 C²++ RAII, DABI und DGCH – Speicher- und Ressourcenmanagement](https://hackmd.io/@UPTOIP/rJjA1wOrbg) - [🔄 C²++ RAII (Resource Acquisition Is Initialization) 1](https://hackmd.io/@UPTOIP/rJCGTTR2xe) - 🔄 C²++ RAII (Resource Acquisition Is Initialization) 2 - 🔄 C²++ DABI (Decay Acquisition by Ignorance) 1 - [🟩 Ephemeral - `T~` Imaginary Values](https://hackmd.io/@UPTOIP/H1mDfiCGWe) - [🧩 C²++-Typsystem Memory Models 2 - `T&` `T&&`](https://hackmd.io/@UPTOIP/Hy7Qlg0G-x) - [♓ C²++ R- und L-Values] - C²++ Reference - [🟩 C²++ safe_reference](https://hackmd.io/@UPTOIP/S1dg6Qu2xx) - [🧩 C²++-Typsystem Memory Models 3 - `T?` `T!`](https://hackmd.io/@UPTOIP/BJU9EclzZe) - ❓ C²++ Nullable - ❗ C²++ Checkable - ❕ C²++ Testable - [🧩 C²++-Typsystem Memory Models 4 - `T*` `T^`](https://hackmd.io/@UPTOIP/Sk_1H_gGWx) - [🔯 C²++ Pointer 1] - [🔯 C²++ Pointer 2] - [🅾️ C²++ null: void* definition](https://hackmd.io/@UPTOIP/Skx8BX7dnxg) - [☀  C²++ Function Pointer](https://hackmd.io/@UPTOIP/ByBoio5nge) - ▲ C²++ Handles - [🧩 C²++-Typsystem Memory Models 5 - `T$` `T#`](https://hackmd.io/@UPTOIP/rk8_0v1GWg) - [C²++ Owner-Mutable-Borrow-Modell](https://hackmd.io/@UPTOIP/BkGqjweCgg) - [C²++ Owner-Borrow-Modell](https://hackmd.io/@UPTOIP/SyVJHgFMZl) - [C²++ Exclusiv-Coupled Lending](https://hackmd.io/@UPTOIP/S1W2ixYMWl) - [C²++ Exclusive Cascade Lending](https://hackmd.io/@UPTOIP/S1W2ixYMWl) - [C²++ Exclusive Window Pending](https://hackmd.io/@UPTOIP/ry_zUeYM-l) - [C²++ Exclusive Window Pending - Window Definitions](https://hackmd.io/@UPTOIP/rkR_lQNMbl) - [⭕ C²++ Exclusive Spatial Cycling X - `T@`](https://hackmd.io/@UPTOIP/HkArjIx8Zx) - [🧩 C²++-Typsystem Memory Models 6 - `T%`](https://hackmd.io/@UPTOIP/rkx77AVGWg) - [🚫 C²++ Peers Objects](https://hackmd.io/@UPTOIP/B1Nmzv0Tll) - [{ }  C²++ Block, break & return](https://hackmd.io/@UPTOIP/By-9HZl6xl) - [🧷 C²++ typed control flows and returns](https://hackmd.io/@UPTOIP/S1nWNgYTee) - [C²++ Types] - C²++ Types 1 - C²++ Types 2 - [〰️ C²++ Fuzzy Types](https://hackmd.io/@UPTOIP/ByyQ0gsAgg) - C²++ Main StartObject - General Operators - General Operators 1 - General Operators 2 - ◯ C²++ Meta Programming - [🏁 C²++ FSM](https://hackmd.io/@UPTOIP/S1nyiuxzbe) - [⚪ C²++ Meta Procedures 1](https://hackmd.io/@UPTOIP/SyBaPB9Alg) - ⚪ C²++ Meta Procedures 2 - ⚪ C²++ Meta Procedures 3 - ⬜ C²++ Meta Types - ⬜ C²++ Meta Types 1 - ⬜ C²++ Meta Types 2 - [📚 core0 - CTL core type library](https://hackmd.io/@UPTOIP/Bk7PLQ9Cel) ## Fundamental Types - [🟢 C²++ sys:: Fundamental Numeric Types](https://hackmd.io/@UPTOIP/HynTYAiCeg) - Character types - `char8` - `char16` - `char32` - `char64` - Boolean type - `bool` - Void type - `void` ## Value Types - [🟩 C²++ std:: Numeric Value Types](https://hackmd.io/@UPTOIP/HkqNU0sAgx) - Character and Boolean Types - `char` - `ascii` - `utf8` - `boolean` - Structures - `struct` - predefined structs (`DateTime`, `TimeSpan`, `Guid`, ...) - Enumerations - `enum` - `flag` - Nullable Types - `Nullable<T>` / `T?` ## Reference Types - Classes - `class` - `object` - predefined classes (`Object`, `String`, ...) - Interfaces - `interface` - Delegates - `delegate` - Multicast delegates - Arrays - `T[]` - Multidimensional arrays (`T[,]`, `T[,,]`) - Jagged arrays (`T[][]`) - Strings - `string` - Dynamic Types - `dynamic` - `variant` - Pointer Types - `*` pointers (implicite unsafe context) - `^` handles ## Special Types - `var` (implicitly typed local variables) - `const` (constants) - `readonly` fields - `ref` / `out` / `in` parameters ## Type Combinations - Generic types (`List<T>`, `Dictionary<TKey, TValue>`, ...) - Nullable types (`T?`) - Nullable reference types (C# 8.0+) - Tuple types (`ValueTuple<T1,T2,...>`) ## Other relevant Types - `object` (base of all types) - `string` (special reference type) - `System.Enum` - `System.ValueType` ## Derived Types - Pointers (`T*`) - References (`T&`, `T&&`) - Arrays (`T[n]`, `T[]`) - Functions (`return_type(param_types)`) - Classes - Structures (`struct`) - Unions (`union`) - Enumerations (`enum` / `enum class`) ## Abstract and Misc Types - Class types - Enum types - Pointer to member types (`T C::*`) - Typedefs / using aliases - Auto type deduction (`auto`) - Decltype (`decltype(expr)`) - nullptr type (`std::nullptr_t`) ## Templates and Generics - Class templates - Function templates - Variadic templates - Template aliases ## Standard Library Types - Standard containers (`std::vector`, `std::array`, `std::list`, `std::map`, ...) - Smart pointers (`std::unique_ptr`, `std::shared_ptr`, `std::weak_ptr`) - Tuples (`std::tuple`) - Strings (`std::string`, `std::wstring`, `std::u16string`, `std::u32string`) ## Type Qualifiers - `const` - `volatile` - `mutable` - `static` - `thread_local` - `extern` ## Other Useful Types - `std::size_t` - `std::ptrdiff_t` - `std::nullptr_t` - Function pointers - Lambda expressions (closure types) ## c4 - 💣 The c4 Tool - 💣 The c4 MarcoProcessor - 💣 The c4 Programming-Language - 💣 The c4 TemplateEngine - 💣 The c4 as PreTemplateMacro System ## Core - [♉ C²++ core0 Fundamentals](https://hackmd.io/@UPTOIP/H1LZ-czTgx) - [♉ C²++ core0 IR/IL](https://hackmd.io/@UPTOIP/S1He2OSpgg) - [♉ C²++ core0 main()](https://hackmd.io/@UPTOIP/rJ2evNXple) - [♉ C²++ core0 Manifest](https://hackmd.io/@UPTOIP/BkZW5iGpxl) - [C²++ Context Cascade Calls/1996](https://hackmd.io/@UPTOIP/rk3otUkW-l) - [C²++ Context Cascade Calls/2001]() - [C²++ Context Cascade Calls 1 - Overview]() - [C²++ Context Cascade Calls 2 - Fundamentals](https://hackmd.io/@UPTOIP/BJQ0jNEVbe) - [C²++ Context Cascade Calls 3 - Basics](https://hackmd.io/@UPTOIP/H1UjAAr4bx) - [C²++ Context Cascade Calls 4 - Concept]() - [C²++ Context Cascade Calls 5 - Kinds](https://hackmd.io/@UPTOIP/B1VlhEVNZx) - [C²++ Context Cascade Calls 6 - Modern Build Monad](https://hackmd.io/@UPTOIP/HyCJNkUV-g) - [C²++ Context Cascade Calls 7 - xyz](https://hackmd.io/@UPTOIP/r1vPd5HNZl) - C²++ core0 Monads/1998 - [♉ C²++ core0 Monads 1](https://hackmd.io/@UPTOIP/Bke9nL4Vplx) - [♉ C²++ Core0 Monads 2](https://hackmd.io/@UPTOIP/B1zRT82Teg) - [♉ C²++ Core0 Monads 3](https://hackmd.io/@UPTOIP/SyAmF2UkWx) - [♉ C²++ Core0 Monads 4](https://hackmd.io/@UPTOIP/SJt8lcYTee) - [♉ C²++ Core0 Monads 5](https://hackmd.io/@UPTOIP/ryJZe551-l) - Monaden Polymorphy - [♉ C²++ core0 Object Oriented](https://hackmd.io/@UPTOIP/rJRiauHall) - [♉ C²++ core0 SysIO](https://hackmd.io/@UPTOIP/BJjXogJaxg) - [♉ C²++ core0 SysIO IOStreams](https://hackmd.io/@UPTOIP/HydNEWV6xg) - [  ∷   C²++ core0 Namespaces]() - [♊ Core SysTypes] - [♊ Core Variables] - [🕎 C²++ Core0 branch](https://hackmd.io/@UPTOIP/SJsvve1Tgx) - [🕎 C²++ core0 Register based](https://hackmd.io/@UPTOIP/B19BVOcpex) - [🕎 C²++ core0 Stack based](https://hackmd.io/@UPTOIP/HkNV9GDTgl) - [🕎 C²++ core0 Stack Programming 1 - Konzept](https://hackmd.io/@UPTOIP/SyDqZwC3ll) - [🕎 C²++ core0 Stack Programming 2 - ABI]() - [🕎 C²++ core0 Stack Programming 3 - Language]() - [🕎 C²++ core0 Stack Programming 4 - Beispiel]() - Core Operators - Core Operators 1 - Core Operators 2 - [🕎 C²++ Core0 Teach](https://hackmd.io/@UPTOIP/ryNcVUETxg) - [⚠ C²++ core0 Error Mechanism](https://hackmd.io/@UPTOIP/ry-XkSkWZl) - [🪞  C²++ Core0 Mirror](https://hackmd.io/@UPTOIP/SJCfBx46gx) - [🔨 C²++ Build 1](https://hackmd.io/@UPTOIP/Symbho5Tle) ## Basics - [🟨 C²++ — Modul Include](https://hackmd.io/@UPTOIP/B1lLOpfheg) - [⏺️ C²++ StdIO] - [▶️ C²++ Types] - [▶️ C²++ Variables] - [⏹️ C²++ Var Typeinference] - [⏹️ C²++ Const] - [⏹️ C²++ Final] - [⏸️ C²++ R- und L-Values] - Typisierte Kontrollflüsse und Rückgaben in C²++ - ❔ C²++ Reflex - Reflection API - Polymorphy: by named values ## Language Levels - C²++ core0-IR - C²++ core0-IL - C²++ core0 - C²++ Manifest code - C²++ core1 - C²++ core2 - C²++ core3 - Language Profiles - Sandbox - Scheduler - SandboxVM - Hosting ## Language Types - Enums - Sets - Sequences - Fields - Arrays - Vectors - Deque - Lists - SingleLists - DoubleLists - Tree - Map - Assoziation - Hash - HashTable - HashTree - HashMap - Queue - PriorityQueue - Stack ## Language Types Builder - bunch -- LowLevel strict aligned nonpadding DataContainer - [🗝 C²++ Bunch Axis - Überblick]() - [🗝 C²++ Bunch Axis **`: offset(call)`**]() - [🗝 C²++ Bunch Axis **`: alignas`**]() - : alignas(n) -- erzwingt def. Speicher-Ausrichtung. - : padding(n) -- implementiert Schnittstelle - Records -- value base, value compared, recrusiv, variant, DataStructure - record - Structs -- mutable, value based, reference compared, DataClass - struct - [🗝 C²++ Struct Axis - Überblick]() - [🗝 C²++ Struct Axis **`: inheritance`**]() - : supports -- unterstützt struct mit configuration - : implements -- implementiert Schnittstelle - : extends -- erweitert Struktur - Entities -- immutable, reference based, value compared, DataPersitanceType - entity - [🗝 C²++ Entity Axis - Überblick]() - [🗝 C²++ Entity Axis **`: inheritance`**]() - : supports -- unterstützt record mit configuration - : implements -- implementiert Schnittstelle - : extends -- erweitert Struktur - [🗝 C²++ Entity Axis **`: marshall`**]() - : marshall -- kodiert einen StringStream mit den daten - : unmarshall -- dekodiert einen StringStream mit den daten - : chk -- kontrolliert ein package/string - XXX - : immutable - : findbyid - : serialize - : deserialize - Unions - Union 1 - Union 2 - Union 3 - Anonyme Unions - union 4 - constructor/destructor - Union 5 and Structs - [🗝 C²++ Unions Axis - Überblick]() - [🗝 C²++ Unions Axis **`: align`**]() - : alignas(n) -- erzwingt bestimmte Speicher-Ausrichtung. - : padding(n) -- implementiert Schnittstelle - : pack -- erzwingt, kein/minimales Padding - : ->sizeof - : ->alignof - Bitfields - [🗝 C²++ Bitfields Axis - Überblick]() - [🗝 C²++ Bitfields Axis **`: inheritance`**]() - : raw -- property get, set - Enums - Enum 1 - [🗝 C²++ Enum Axis - Überblick]() - [🗝 C²++ Enum Axis **`: enum`**]() - : based -- basiert auf ordinal type O - : realise -- realisiert die Implementierung mit I - : expands -- erweitert die symbolwerte von E - Enum FSM - Flags - [🗝 C²++ Enum Axis - Überblick]() - [🗝 C²++ Enum Axis **`: flag`**]() - : based -- basiert auf ordinal type O - : expands -- erweitert die symbolwerte von E - Sets - Sets ValueKinds - [🗝 C²++ Sets Axis - Überblick](https://hackmd.io/@UPTOIP/HyHeFo1All) - [🗝 C²++ Sets Axis **`: set`**]() - : based -- nur alias auf Basistypen B - : symbols -- neue Symbole - Bags - Bags ValueKinds - [🗝 C²++ Sets Axis - Überblick](https://hackmd.io/@UPTOIP/HyHeFo1All) - [🗝 C²++ Sets Axis **`: bag`**]() - : symbols -- neue Symbole ## Language Type System - Type based Literal Parsing - Type based Control Structures - Type defined Operators - Type defined Operators: binding - Type defined Operators: association - Polymorphy: by type aliases ## Functions - [📒 C²++ Functions 1](https://hackmd.io/@UPTOIP/S1yoFbV2el) - [📒 C²++ Functions 2](https://hackmd.io/@UPTOIP/HySnKN0JWe) - [📒 C²++ Functions 3] - [📒 C²++ Functions 4] - [📒 C²++ Functions 5] - [📒 C²++ Functions 6] - [📒 C²++ Extention Function] - Function Calls as LValues - [📒 C²++ Function Types](https://hackmd.io/@UPTOIP/HylWWAinlx) - [📒 C²++ Parameterpassing 1 - Call by](https://hackmd.io/@UPTOIP/BJSptE8WWe) - [📒 C²++ Call by Copy Value] - [📒 C²++ Call by Reference] - [📒 C²++ Call by Const Reference] - [📒 C²++ Call by Reference [const]] - [📒 C²++ Call by Reference [out]] - [📒 C²++ Call by Reference [inout]] - [📒 C²++ Call by Reference [trans]](https://hackmd.io/@UPTOIP/r1Z-Ryuybg) - [📒 C²++ Call by Reference [eval]](https://hackmd.io/@UPTOIP/Hy69skdkZe) - [📒 C²++ Call by Reference [consteval]] - [📒 C²++ Call by Alias] - [📒 C²++ Call by Temporary Owner] - [📒 C²++ Call by Borrow] - [📒 C²++ Parameterpassing 2 - params](https://hackmd.io/@UPTOIP/SJQXBedyZl) - 🌟 Rekrusion - 🌟 Continuation-Passing Style (CPS) - [📒 C²++ Runtime - Function Qualifier](https://hackmd.io/@UPTOIP/HJhzEvJNbe) - 📒 C²++ Function Qualifier `final` - [📒 C²++ Function Qualifier `pure` - isolation](https://hackmd.io/@UPTOIP/B1qNJjTWbx) - 📒 C²++ Function Qualifier `memoized` - 📒 C²++ Function Qualifier `stable` - [📒 C²++ Function Qualifier `volatile`](https://hackmd.io/@UPTOIP/ry6Fiqa-Wg) - 📒 C²++ Function Qualifier `safe` - [📒 C²++ Function Qualifier `nothrow`](https://hackmd.io/@UPTOIP/B1_Mnjp-Zx) - 📒 C²++ Function Qualifier `throws()` - [📒 C²++ Function Qualifier `noexcept`](https://hackmd.io/@UPTOIP/SkPjCop-Zg) - 📒 C²++ Function Qualifier `nosend` - 📒 C²++ Function Qualifier `sends()` - 📒 C²++ Function Qualifier `nosignal` - 📒 C²++ Member Qualifier `yield` - 📒 C²++ Member Qualifier `reentrant` - 📒 C²++ Member Qualifier `eager` - 📒 C²++ Member Qualifier `lazy` - 📒 C²++ Member Function Member Qualifier - class - 📒 C²++ Member Qualifier `const` - 📒 C²++ Member Qualifier `final` - [📒 C²++ Member Qualifier `volatile`](https://hackmd.io/@UPTOIP/HyNSfc6W-g) - 📒 C²++ Member Qualifier `valid`/`invalid` - 📒 C²++ Compiletime Function Qualifier - 📒 C²++ Function Qualifier `build` - 📒 C²++ Function Qualifier `artefact` - 📒 C²++ Function Qualifier `script` - [📒 C²++ HowTo Define a Qualifier - example `volatile`](https://hackmd.io/@UPTOIP/HJTdb5FV-g) - [📒 C²++ HowTo Define a Qualifier - example `valid`/`invalid`](https://hackmd.io/@UPTOIP/HJmF-v7EZg) - [📒 C²++ Function Overloading] - ✨ C²++ conversion models - ✨ C²++ strict conversions - ✨ C²++ clean conversions - [✨ C²++ narrowing conversions](https://hackmd.io/@UPTOIP/HJX--0OCgg) - [✨ C²++ Object Inheritance](https://hackmd.io/@UPTOIP/H1sSXtbaxg) - [✨ C²++ Covariant & Contravariant](https://hackmd.io/@UPTOIP/rkeRFcLZTlx) - [✨ C²++ In-, Co- und Contravariant 1](https://hackmd.io/@UPTOIP/Hy3aekJBbl) - [✨ C²++ Overload Resolution 1](https://hackmd.io/@UPTOIP/r1lOA_WTgl) - [✨ C²++ Overload Resolution 2](https://hackmd.io/@UPTOIP/HJS2Jg_1-x) - [✨ C²++ Calling Conventions](https://hackmd.io/@UPTOIP/BJe5ocMTlg) - Polymorphy: by function overloading - [✨ C²++ Currying & Uncurrying](https://hackmd.io/@UPTOIP/BkT1xwZpel) - [📒 C²++ Functions Axis](https://hackmd.io/@UPTOIP/HyHeFo1All) - [📒 C²++ Functions Axis **`: dispatch`**](https://hackmd.io/@UPTOIP/r1Ezr8pael) - : dispatch -- dynamischer Router, Dispatcher, oder ein Funktionsmultiplexer - [📒 C²++ Functions Axis **`: aspects`**](https://hackmd.io/@UPTOIP/Sk4-RNapgx) - : before -- Preparation, Logging, Pre-Aktionen - : start -- Initialisierungen, Timer starten, Zustände setzen - : skip -- Funktion nicht ausführen, z. B. wegen Cache-Hit, Zustand, Filter - : replace -- substituiert den Funktionskörper vollständig - : return -- Nachbearbeitung des Return-Wertes - : after -- Logging, Cleanup, Post-Aktionen - [📒 C²++ Functions Axis **`: invariants`**](https://hackmd.io/@UPTOIP/rkYikUp6gg) - : require -- Vorbedingung (Precondition) - : variant -- Variantenprüfung (Termination Proof) - : yield -- Schleifenprüfung (Iteration Proof) - : ensure -- Nachbedingung (Postcondition), Statusprüfung - [📒 C²++ Functions Axis **`: watch`**](https://hackmd.io/@UPTOIP/r1cBjbtpex) - : watchbeat -- Eskalationsstrategie: Exceptions bei Timeout ohne watch.ack() - : watchping -- hearth beat closure execution via async oder thread context - : watchdog -- closure die wärend async oder aus dem thread antworten kann, wenn ok - [📒 C²++ Functions Axis **`: timeout`**](https://hackmd.io/@UPTOIP/rk1mKt2Tee) - : timeout -- Maximalzeit, nach der eine Funktion abgebrochen wird (Zeitbeschränkung) - [📒 C²++ Functions Axis **`: cache`**](https://hackmd.io/@UPTOIP/SkDyUkTTlx) - : cache -- Memoisierung oder Zwischenspeicherung von Ergebnissen (Caching-Achse) - ------------------------------------------ - : authorise -- Ausführungsberechtigung execution `: skip` - : capability - : check - : when - : retry - : recover - : rescue - [ƒ C²++ Function Interface]() - [ƒ C²++ Function Inheritance](https://hackmd.io/@UPTOIP/SkgqkRl6ee) - [🚧 C²++ Program Main] - [🚧 C²++ Program LifeCycle: Start] - [🚧 C²++ Program LifeCycle: Exit & Abort](https://hackmd.io/@UPTOIP/HkvoOhL2gg) - [📗 C²++ Function Nested Types](https://hackmd.io/@UPTOIP/BJDZuIT6xx) - [📗 C²++ Sub Functions 1](https://hackmd.io/@UPTOIP/r15MB9-3lg) - [📗 C²++ Sub Functions 2](https://hackmd.io/@UPTOIP/rJh7Hq06le) - [📗 C²++ Nested Functions 1](https://hackmd.io/@UPTOIP/BJbcucWhlx) - [📗 C²++ Nested Functions 2] - [📗 C²++ Nested Functions 3](https://hackmd.io/@UPTOIP/r1LgHXTnxg) - [📗 C²++ Nested Member Functions 1](https://hackmd.io/@UPTOIP/rkw2LtFall) - Polymorphy: by function renesting - [📘 C²++ Method Calls 1](https://hackmd.io/@UPTOIP/ryfMIKZnxl?view) - [📘 C²++ Method Calls 2](https://hackmd.io/@UPTOIP/HytgfIB2lx) - 📘 C²++ Async Peers - 📘 C²++ Afork Peers 1 - 📘 C²++ Afork Peers 2 - [📕 C²++ Closures 1](https://hackmd.io/@UPTOIP/BkGgO5-nex) - [📕 C²++ Closures 2](https://hackmd.io/@UPTOIP/HJC99jnnll) - [📕 C²++ Closures 3](https://hackmd.io/@UPTOIP/H1cbW6A3xx) - [🐛 C²++ Larva & Papillon] - [🦋 C²++ Papillons] - Polymorphy: by closure mutli signatures - [📦 C²++ Function Objects: Einführung](https://hackmd.io/@UPTOIP/SJE_zl8yWe) - [📦 C²++ Function Objects 1](https://hackmd.io/@UPTOIP/H1R6lvZ2xx) - [📦 C²++ Function Objects 2](https://hackmd.io/@UPTOIP/SkX2eD-hlg) - [📦 C²++ Function Objects 3](https://hackmd.io/@UPTOIP/B1dyPyynee) - Polymorphy: by functionobject binding - [☀ C²++ Function Pointer](https://hackmd.io/@UPTOIP/ByBoio5nge) - [📙 C²++ Multi-Methods 1](https://hackmd.io/@UPTOIP/Hknj8Wpjex) - [📙 C²++ Multi-Methods 2](https://hackmd.io/@UPTOIP/rJIQiRColx) - [📙 C²++ Multi-Methods 3](https://hackmd.io/@UPTOIP/BJYfnYM3gl) - [🌈 C²++ Parameter Signature Inheritance (PSI) 1]() - [🌈 C²++ Parameter Signature Inheritance (PSI) 2](https://hackmd.io/@UPTOIP/r1IEtonsle) - [⛓️ C²++ Pipelining](https://hackmd.io/@UPTOIP/H1EqSOYnge) ## Context - Context what is it? - this (static) - base - that - cache (last, start, current) - call - error - except - exec - exit - meta - runtime - signal - watch - [✅ C²++ Context-Oriented Programming (COP)](https://hackmd.io/@UPTOIP/HkOXgWThee) - Polymorphy: by context ## Monads - Monaden 1 - Monaden 2 - Monaden 3 - Monadische Effekt-Programmierung (MEP) - SCLLC - Polymorphy: by monads ## The O-World - [⭐ C²++ Object Welten](https://hackmd.io/@UPTOIP/SJQ8MrXSZl) - [🌱 C²++ Class Inheritance](/Bj7Bk8uATKqckCSy9RIP0w) - [🌱 C²++ Class Refinement](/DibvwtYISMygHM4FFv4cIw) ## Objects - [✔ C²++ Objects 1](https://hackmd.io/@UPTOIP/Skj3aYtbbx) - [✔ C²++ Objects 2](https://hackmd.io/@UPTOIP/HJSOcnK-bg) - [✔ C²++ Object Model 1 - Smalltalk](https://hackmd.io/@UPTOIP/HkCeb-tbbg) - [✔ C²++ Object Model 2 - Self](https://hackmd.io/@UPTOIP/S1lxa67rbl) - C²++ Object Model 3 - JavaScript - [🗝 C²++ Object Axis] - [🗝 C²++ Object Axis **`: dispatch`**] - : dispatch -- dynamischer Dispatcher - [🗝 C²++ Object Axis **`: prototype`**] - : lookup -- lookup controller - : rai -- reallocation of prototype instances - [🗝 C²++ Object Axis **`: typedefs`**] - : clone -- kopiert - : class -- realisiert die Implementierung mit T - : mutable -- erweitert die symbolwerte von E - Creation - Creation by Object-Class - Creation by Cloning - Creation by Mutable - C²++ Objektmutability - Add Routines - Remove Routines - Add Attribute - Remove Attribute - [C²++ Lexical Structural Typing](https://hackmd.io/@UPTOIP/Hk9Lo3IWWl) - Polymorphy: by Semantic Structural Typing - [C²++ Object Bridge to Class](https://hackmd.io/@UPTOIP/H18spHtbZe) - Inheritance by Prototype - Prototype-Based Programming (PbP) - Polymorphy: by Objects - Dynamic - Polymorphy: by DuckTyping ## Entities - 🛢️ C²++ Entity - 🛢️ C²++ Member - 🛢️ C²++ Constructors - 🛢️ C²++ Brace-Initialization ## Structs - constructors - property axis - get - set - init - container manips - pop - push - events ## Classes - Class - Class - [🗝 C²++ Class Axis] - [📒 C²++ Class Axis **`: invariants`**](https://hackmd.io/@UPTOIP/rkYikUp6gg) - : require -- Vorbedingung (Precondition) - : variant -- Variantenprüfung (Termination Proof) - : ensure -- Nachbedingung (Postcondition), Statusprüfung - [🌱 C²++ Class Axis **`: inheritance`**](https://hackmd.io/@UPTOIP/HkbKr8pCll) - : inheritance-- ableiten von Basisklasse B `(non-virtual, new, single-inheritance, deep, invariant)` - : extends -- erweitere Basisklasse B `(non-virtual, override, multi-inheritance, deep, covariant)` - : virtual<=invariant|+covariant|-contravariant> -- erweitere Basisklasse B `(virtual, override, multi-inheritance, deep, variant)` - : derive -- ableiten Basisklasse B `(non-virtual, new, multi-inheritance, flat, invariant)` - : infer -- ableiten Basisklasse B `(non-virtual, new, single-inheritance, flat, invariant)` - : implements -- Implementiert Schnittstelle `(inter-poly, none, single-inheritance, none)` - [🗝 C²++ Class Axis **`: meta`**] - : meta -- verknüpft meta class - [🗝 C²++ Class Axis **`: aspects`**] - : adapts -- Adaptiert Feature, Apsects - [📒 C²++ Class Axis **`: dispatch`**] - : dispatch -- dynamischer Router, Dispatcher, oder ein Funktionsmultiplexer - [📒 C²++ Class Axis `: catch`] - : catch -- ... - [📒 C²++ Class Axis `: receive`] - : receive -- .... - Class Member - Constructors - Copy Constructor - Move Constructor / Value Constructor - [📦 C²++ const Constructors](https://hackmd.io/@UPTOIP/BJ0jFBWkWl) - [📦 C²++ omission default Constructors](https://hackmd.io/@UPTOIP/BykU6fHB-e) - [📦 C²++ Inline Direct Constructors](https://hackmd.io/@UPTOIP/r1Vw3iFagl) - [📦 C²++ Convention over Configuration](https://hackmd.io/@UPTOIP/H1fmlhYplx) - Destructor - Properties - Property - Property - Property - [📒 C²++ Property Axis](https://hackmd.io/@UPTOIP/HyHeFo1All) - [📒 C²++ Property Axis **`: getter/setter`**]() - : get -- dynamischer Router, Dispatcher, oder ein Funktionsmultiplexer - : set -- dynamischer Router, Dispatcher, oder ein Funktionsmultiplexer - [📒 C²++ Property Axis **`: init`**]() - : init -- initialisierung - [📒 C²++ Property Axis **`: container`**]() - : pop -- Initialisierungen, Timer starten, Zustände setzen - : push -- Funktion nicht ausführen, z. B. wegen Cache-Hit, Zustand, Filter - Methods - C²++ class - Method-Qualifier `const` - [📦 C²++ class - Method-Qualifier `volatile`](https://hackmd.io/@UPTOIP/HyNSfc6W-g) - C²++ class - Function-Qualifier `pure` - C²++ class - Function-Qualifier `final` - virtual Methods - C²++ Parzielle Klassen - C²++ `partial class` 1 - [C²++ `partial class` 2](https://hackmd.io/@UPTOIP/Sk0RcGSrZe) - abstract Class - anonymious Class - static Class - ClassLoaders - Class Constants - Class Variables - Class Properties - Class Functions - Friend Class & Class Friend - Meta Class - [🛑 C²++ Meta Class](https://hackmd.io/@UPTOIP/BJCxuTXAxg) - Extention Methods - sealed Class - Class Inheritance - override Methods - overlap Methods - Derived Constructors - Base Constructors - Destructor execution - Class Reflection - [📌 C²++ RTTI 1](https://hackmd.io/@UPTOIP/r1oMcaA2xl) - MCID - Reflex (Reflection API) - Class Extention - [🧬 C²++ Mixin](https://hackmd.io/@UPTOIP/BJJWuTC3ll) - Separation of Concern (SoC) - Aspects - Features - Cross-Cutting Concern (CCC) - Design by Contract (DbC) - [🍩 C²++ Class Invariants 1](https://hackmd.io/@UPTOIP/H1FM59S3ee) - [🍩 C²++ Class Invariants 2](https://hackmd.io/@UPTOIP/r1YHQbdTxe) - require - ensure - Public Invariant Policy (PIP) - Object-oriented Programming (OOP) - SOLID+D - GRASP - Polymorphy: by Classes - Polymorphy: by Class-Instances ## Interfaces - 🔍 C²++ Function Interfaces - 🔍 C²++ Class Interfaces - 🗝 C²++ Interfaces Axis - [🗝 C²++ Interface Axis **`: inheritance`**] - : supports -- unterstützt Basisschnittstelle I - 🔍 C²++ Class Interface 1 - 🔍 C²++ Class Interface 2 - 🔍 C²++ Class Interface 3 - named - 🔍 C²++ Class Interface 4 - inline - Polymorphy: by Interface - [C²++ Sealed Interfaces](https://hackmd.io/@UPTOIP/Hkg2y0Tz-e) - [C²++ Bodies](https://hackmd.io/@UPTOIP/SyQjCCTGbg) ## Views - [🪟 C²++ Views 1](https://hackmd.io/@UPTOIP/ryuAqk02ex) - 🪟 C²++ Views 2 - Polymorphy: by Display ## Design Patterns - [🔬 C²++ DesignPatterns - Observer](https://hackmd.io/@UPTOIP/B13O4tApel) ## Subjects - [🔎 C²++ Subject Oriented Programming (SOP)](https://hackmd.io/@UPTOIP/rJ-o7O1nel) - [🔎 C²++ Subject 1](https://hackmd.io/@UPTOIP/ryM4DSeCel) - 🔎 C²++ Subject 2 - [🔗 C²++ Type-Dependent Types]() - 🔗 C²++ Type-Dependent Types - Polymorphy: by Subject ## Composites * Composites ## Mixins - [🧬 C²++ Mixin - Overview](https://hackmd.io/@UPTOIP/BJJWuTC3ll) - [🧬 C²++ Mixins 1](https://hackmd.io/@UPTOIP/ry8t7N3rbe) - [🧬 C²++ Mixins 2](https://hackmd.io/@UPTOIP/Sy6BB7aB-e) - [🧬 C²++ Mixins 3](https://hackmd.io/@UPTOIP/ByHnGSpTxg) - [🧩 C²++ Dispatch Object](https://hackmd.io/@UPTOIP/Sy0EYXTAeg) ## Aspects - [📍 C²++ Aspects](https://hackmd.io/@UPTOIP/r1wQZr6pll) - 📍 C²++ Aspect 1 - 📍 C²++ Aspect 2 - 📍 C²++ Aspect 3 - 📌C²++ Aspect weaving - ✂ C²++ Aspect decomposition - [⚡ C²++ Cooperative Aspect Targets Systemsyntax (CATS)](https://hackmd.io/@UPTOIP/rkOjd6kAll) - [⚡ C²++ Model for Embedded Aspects](https://hackmd.io/@UPTOIP/H1-TBhkAgl) - Separation of concerns (SoC) - C²++ Aspect Oriented Programmng (AOP) ## Features - [🪶 C²++ Features](https://hackmd.io/@UPTOIP/By5NAGgTll) - 🪶 C²++ Feature 1 - 🪶 C²++ Feature 2 - 🪶 C²++ Feature 3 - 🪶 C²++ Feature Agreements - 📌 C²++ Feature binding - 📌 C²++ Feature layers - [C²++ Feature Oriented Programming (FOP)](https://hackmd.io/@UPTOIP/r17GfuhZ-x) ## Meta - [❌ C²++ meta-oriented](https://hackmd.io/@UPTOIP/r1_C8DF2lx) - ✔ C²++ CompileTime Programming - ✖ C²++ Meta Programming - [➖ C²++ Generics](https://hackmd.io/@UPTOIP/BJvxw8K2ex) - [➕ C²++ Templates](https://hackmd.io/@UPTOIP/B1yfglc2ex) - [➗ C²++ Templates & Generics](https://hackmd.io/@UPTOIP/B1jeVD3Ceg) - [➗ C²++ template vs generic](https://hackmd.io/@UPTOIP/ryUg_UKhge) - [💬 C²++ Annotations 1](https://hackmd.io/@UPTOIP/S16dIf2Rlx) - [💬 C²++ Annotations 2](https://) - [**⟦ ⟧** C²++ Code based Configuration (CbC)](https://hackmd.io/@UPTOIP/S1uKLWl3lg) - Template-Meta-Programming (TMP) - Polymorphy: by Templates ## Continuation - [C²++ Continuation](https://hackmd.io/@UPTOIP/B1GlLCWRxl) - [🕹️ C²++ Concurrency Controlled Continuation](https://) ## Concurrency - [🌀 C²++ Concurrency](https://hackmd.io/@UPTOIP/BkvwDX32el) - [⚙️ C²++ Async, Afork und Atask](https://hackmd.io/@UPTOIP/HyqbYhlCxg) - [⏳ C²++ async/afork/suspend 1] - [⏳ C²++ async/afork/suspend 2] - [🐛 C²++ SusPap] - [🛞 C²++ Runtime] - [🧵 C²++ Threads 1](https://hackmd.io/@UPTOIP/H1vUVpY2xl) - [🧵 C²++ Threads 2] - [🌿 C²++ GreenThreads 1] - [🌿 C²++ GreenThreads 2] - [🔴 C²++ RedThreads 1] - [🔴 C²++ RedThreads 2] - [🔴 C²++ RedThreads 3] - [⬛ C²++ Processes 1] - [⬛ C²++ Processes 2] - [⚫ C²++ BlackProcesses 1] - [⚫ C²++ BlackProcesses 2] - [⚙️ C²++ GreyTasks 1] - [⚙️ C²++ GreyTasks 2] ## Messaging - [🛟 C²++ Exceptions 1] - [🛟 C²++ Exceptions 2] - [🛟 C²++ Exceptions 3](https://hackmd.io/@UPTOIP/r1NB75Shll) - [🛟 C²++ Exceptions 4 - throws](https://hackmd.io/@UPTOIP/HyWJ5pwage) - [🛟 C²++ Exceptions 5 - Move-Optimierung](https://hackmd.io/@UPTOIP/SJ-aspwTel) - [🚦 C²++ Signals 1](https://hackmd.io/@UPTOIP/S1ysf2U2le) - [🚦 C²++ Signals 2](https://hackmd.io/@UPTOIP/SJzEz6Lhex) - [🚦 C²++ Signals 3](https://hackmd.io/@UPTOIP/BkCOHZvnge) - [⚡ C²++ Interrupt Handler](https://hackmd.io/@UPTOIP/BJ5fxYunee) ## Realtime - [⏱️ C²++ RealTime Programming](https://hackmd.io/@UPTOIP/rJzmmYd2xg) - C²++ RealTime 1 Fundamentals - C²++ RealTime 2 Preconditions - C²++ RealTime 3 Steps - C²++ RealTime 4 Embed - C²++ Embedded core0 - C²++ Embedded core0 as inplaced RealTime scope - C²++ Embedded core0 RealTime Examples - C²++ RealTime 5 in Dual-Main Setups - C²++ core0 main - C²++ core0 main RealTime - C²++ RealTime 6 as/in RedThread (POSIX-Like Thread) - C²++ core0 RedThread RealTime - C²++ RealTime 7 in GreenThread (shared pooled Thread) - C²++ core0 GreenThread RealTime - C²++ RealTime 8 in FOroutines ## Embedded - [🔌 H²++ coreH SCOP](https://hackmd.io/@UPTOIP/H10ohfI-Ze) - [🔌 H²++ coreH SROP](https://hackmd.io/@UPTOIP/Hy_7L7U-Wg) --- --- ## 📘 **C²++ Language Reference: core0** ### 1️⃣ `core0-overview.md` > *Einführende, erklärende Dokumentation mit Designmotiven und Philosophie.* Beinhaltet: * Konzept & Rolle von `core0` * Beziehung zu C²++ / IR / IL * Designprinzipien (Determinismus, Monaden, Branch) * Beispielprogramme (Hello World, Interrupts, UI-Fluent) * Unterschiede zu C / C++ / LLVM IR ➡ Zielgruppe: Entwickler, Forscher, Sprach- und Compilerarchitekten. --- ### 2️⃣ `core0-specification.md` > *Formale Sprachdefinition mit Syntax, Semantik und Verhalten.* Beinhaltet: * **Lexikalische Spezifikation** * Token-Arten, Literale, Labels, Branches * **Syntax** * Statements, Branches, Goto, Labels * Contexts (`context<<T@>>`), Monadenbindung * Structs, Functions, Includes, Namespaces * **Semantik** * RAII-Lifetime-System, Ownership, Borrowing * Grouped Returns (`||`, `&&`) * Error Handling & Signals * Interrupts & Determinismus * Sandbox-Semantik * **Type-System** * Builtins (`int`, `real`, `bool`, `bcd`, etc.) * `sys::*` Typenbibliothek * Template-Mechanik ohne Generics * Compile-Time-Kontextualisierung * **Execution Model** * `branch(int) goto label` * Block/Label Semantik * Stack Frames, Ownership Transfer, Return Rules * **Core Runtime** * `sys::io`, `sys::types`, `sys::error`, `sys::sched` * Interrupt handling (`interrupt(TIMER0)`) ➡ Zielgruppe: Compiler- und VM-Implementierer. --- ### 3️⃣ `core0-reference.md` > *Formaler API/Library-Level: alles, was unter `sys::*` als Standardbibliothek verfügbar ist.* Beinhaltet: * `sys::types::*` * `sys::io::console` * `sys::error` * `sys::sched` * `sys::memory` * `sys::data::*` * `sys::ui::*` ➡ Zielgruppe: Entwickler, die direkt in `core0` programmieren (z. B. für Embedded, Sandbox, VM). --- --- ## 📘 Inhaltsverzeichnis – C++ Tutorial ### **Teil 1: Einführung in C++** 1. Was ist C++? 2. Geschichte & Merkmale von C++ 3. Installation von Compiler und Entwicklungsumgebung (g++, MSVC, Clang, IDEs wie VS Code, CLion) 4. Erstes C++-Programm – Hello World 5. Aufbau eines C++-Programms 6. Kompilieren und Ausführen --- ### **Teil 2: Grundlagen der Sprache** 7. Datentypen und Variablen 8. Operatoren (arithmetisch, logisch, Vergleich) 9. Ein- und Ausgabe (`cin`, `cout`) 10. Kontrollstrukturen (if, else, switch) 11. Schleifen (for, while, do-while) 12. Funktionen – Deklaration, Definition, Aufruf 13. Gültigkeitsbereiche und Speicherklassen (`static`, `extern`, `register`) 14. Referenzen und Zeiger 15. Arrays und Strings 16. Enums und `typedef` --- ### **Teil 3: Objektorientierte Programmierung** 17. Klassen und Objekte 18. Konstruktoren und Destruktoren 19. Memberfunktionen und Datenkapselung 20. Vererbung und Polymorphismus 21. Abstrakte Klassen und Interfaces (`virtual`, `pure virtual`) 22. Überladen von Operatoren 23. Statische Member 24. `this`-Zeiger --- ### **Teil 4: Fortgeschrittene C++-Konzepte** 25. Templates (Funktionen und Klassen) 26. Ausnahmebehandlung (`try`, `catch`, `throw`) 27. STL – Standard Template Library * Vektoren, Listen, Maps, Sets * Algorithmen (`sort`, `find`, etc.) * Iteratoren 28. Lambda-Ausdrücke 29. Funktoren und `std::function` 30. Smart Pointer (`unique_ptr`, `shared_ptr`, `weak_ptr`) 31. Namespaces und `using` 32. Präprozessor-Direktiven (`#define`, `#include`, `#ifdef`, etc.) --- ### **Teil 5: Speicher & Performance** 33. Dynamische Speicherverwaltung (`new`, `delete`) 34. Speicherlecks und RAII 35. Stack vs Heap 36. Move Semantik und Rvalue References 37. Copy/Move Constructor & Assignment Operator --- ### **Teil 6: Arbeiten mit Dateien & System** 38. Dateiein- und -ausgabe (`fstream`) 39. Fehlerbehandlung bei IO 40. Arbeiten mit Zeit und Datum 41. Kommandozeilenargumente 42. Multithreading (ab C++11: `std::thread`) 43. Mutexes, Locks, Synchronisation 44. C++ und das Betriebssystem (Basics) --- ### **Teil 7: C++ in der Praxis** 45. Projektstruktur und Header-Dateien 46. Makefiles und Build-Systeme (Make, CMake) 47. Unit-Testing (z.B. Google Test) 48. Debugging (gdb, Visual Studio Debugger) 49. Performance-Optimierung 50. C++ Coding Standards und Best Practices --- ### **Teil 8: Moderne C++ (C++11 bis C++23)** 51. Überblick über C++11, C++14, C++17, C++20, C++23 52. Neue Features: * `auto`, `nullptr`, `constexpr`, `decltype` * Range-based Loops, `std::optional`, `std::variant` * Concepts und `requires` (ab C++20) * Coroutines, Modules, Pattern Matching (ab C++23) --- ### **Teil 9: Anhang & Ressourcen** 53. Nützliche Bibliotheken (Boost, fmt, etc.) 54. C++ vs andere Sprachen 55. Interview-Fragen und Aufgaben 56. Weiterführende Literatur & Links 57. Glossar wichtiger Begriffe

Syntax	Example	Reference
# Header	Header	基本排版
- Unordered List	Unordered List
1. Ordered List	Ordered List
- [ ] Todo List	Todo List
> Blockquote	Blockquote
Bold font	Bold font
Italics font	Italics font
~~Strikethrough~~	~~Strikethrough~~
19^th^	19^th
H~2~O	H₂O
++Inserted text++	Inserted text
==Marked text==	Marked text
[link text](https:// "title")	Link
![image alt](https:// "title")	Image
`Code`	`Code`	在筆記中貼入程式碼
```javascript var i = 0; ```	`var i = 0;`
:smile:		Emoji list
{%youtube youtube_id %}	Externals
$L^aT_eX$	L^aT_eX
:::info This is a alert area. :::	This is a alert area.