Tartalomjegyzék

I. rész: C alapok és rendszerprogramozás

1 A C és C++ mentális modellje és a labor környezete

• 1.1 Absztrakt gép, forrásprogram és natív folyamat
• 1.2 Szabványok, dialektusok és hordozhatósági szerződés
• 1.3 Reprodukálható fordítási és diagnosztikai labor
• 1.4 A szükséges C szintaxis tömör áttekintése
• 1.5 Első megfigyelési ciklus a forrástól a futásig

2 A fordítás és a preprocessor C-ben

• 2.1 Fordítási fázisok és fordítási egységek
• 2.2 Headerek, deklarációk és include-higiénia
• 2.3 Makrók, feltételes fordítás és veszélyes helyettesítés
• 2.4 Preprocessor-labor és feature detection
• 2.5 Warningok, optimalizálási profilok és link-driver

3 Linkelés, ELF, programindulás és leállás

• 3.1 Szimbólumok, linkage és relocation
• 3.2 Statikus és megosztott könyvtárak
• 3.3 ELF-betöltés, PLT/GOT és dinamikus szimbólumok
• 3.4 main, startup, argumentumok és környezet
• 3.5 Leállás, cleanup és nem lokális vezérlés

4 C adattípusok, konverziók és kifejezések

• 4.1 Egész típusok és adatmodellek
• 4.2 Promóciók, signedness és túlcsordulás
• 4.3 Lebegőpontos reprezentáció és numerikus hibák
• 4.4 Deklarációk, typedef és típusminősítők
• 4.5 Kifejezések kiértékelése, sequencing és bitműveletek

5 C objektumok, tárolási idő és memóriamodell

• 5.1 Scope, linkage, storage duration és lifetime
• 5.2 C objektumok a folyamat virtuális címterében
• 5.3 Inicializálás, indeterminate érték és reprezentáció
• 5.4 Effective type, aliasing és objektumreprezentáció
• 5.5 Élettartam- és memóriahibák vizsgálati laborja

6 Pointerek és összetett deklarációk C-ben

• 6.1 Címképzés, dereferencia és null pointer
• 6.2 Pointeraritmetika, objektumhatár és provenance
• 6.3 const pointerek, több szintű indirection és void*
• 6.4 Deklarátorok: tömb-, pointer- és függvénykapcsolatok
• 6.5 Függvénypointerek, callbackek és context pointer

7 Tömbök, sztringek és nem tulajdonló adatszeletek C-ben

• 7.1 Tömbobjektum, decay és függvényparaméter
• 7.2 Többdimenziós tömbök, VLA és layout
• 7.3 Nullterminált sztring és a hossz szerződése
• 7.4 Memóriamásolás, összehasonlítás és byte view
• 7.5 Szövegkódolás, locale és UTF-8 C-ben

8 Dinamikus memória és explicit tulajdonlás C-ben

• 8.1 malloc, calloc, free és allokációs szerződés
• 8.2 realloc és dinamikusan növekvő buffer
• 8.3 Alignment és speciális allokációk
• 8.4 Tulajdonlási szerződés és cleanup ágak
• 8.5 Allokációs hiba-injektálás és leak diagnosztika

9 struct, union, alignment és bináris layout

• 9.1 Struktúrák, tagok és értékmásolás
• 9.2 Padding, alignment és offsetof
• 9.3 Union, tagged union, enum és bit-field
• 9.4 Byte order és biztonságos szerializálás
• 9.5 Layout- és protokolllabor két architektúrán

10 Függvények, modulok és C API-tervezés

• 10.1 Függvényhívás, prototípus és paraméterátadás
• 10.2 Variadikus függvények és típusbiztonság
• 10.3 static inline, _Generic és headeres eszköztár
• 10.4 Opaque handle és stabil C könyvtári interfész
• 10.5 C API-szerződések ellenőrzése

11 A C standard könyvtár és hibakezelés

• 11.1 stdio, FILE és pufferelés
• 11.2 Formázás és megbízható szövegfeldolgozás
• 11.3 Hibakód, errno és hibaadatok élettartama
• 11.4 Idő, véletlen és környezeti állapot
• 11.5 Numerikus és ritkább C könyvtári eszközök térképe

12 C mint Linux/POSIX rendszerprogramozási nyelv

• 12.1 File descriptor és robusztus I/O ciklus
• 12.2 Fájlrendszer-műveletek, mmap és tartósság
• 12.3 fork, exec, pipe és gyermekfolyamat
• 12.4 Signal, megszakítás és graceful shutdown
• 12.5 Socket API, framing és bufferkezelés
• 12.6 poll/epoll és explicit eseményállapotgép

13 Adatszerkezetek és parser C-ben

• 13.1 Dinamikus tömb és string builder
• 13.2 Láncolt és intrusive listák
• 13.3 Hash table, comparator és ownership
• 13.4 Arena, pool és region lifetime
• 13.5 Bounds-ellenőrzött parser és állapotgép

14 Assembly, hívási ABI és hardverkapcsolatok

• 14.1 C forrásból assembly és gépi kód
• 14.2 Hívási konvenció, stack frame és visszatérés
• 14.3 Optimalizáló, as-if és UB következményei
• 14.4 Cache, locality, alignment és false sharing
• 14.5 volatile, compiler barrier és hardver barrier
• 14.6 ABI- és optimalizálásdiagnosztikai labor

15 Szálak és atomikus műveletek C-ben

• 15.1 Szál-életciklus, pthreads és C11 threads
• 15.2 Data race, happens-before és publikalás
• 15.3 Mutex, condition variable és producer–consumer
• 15.4 C atomics és memory order
• 15.5 Konkurens élettartam és nehéz hibák

16 C hibakeresés, tesztelés és biztonságos kód

• 16.1 Debugger, core dump és optimalizált program
• 16.2 ASan, UBSan, MSan, TSan és Valgrind
• 16.3 Unit test, property test és fuzzing
• 16.4 C biztonsági hibaminták és védekezés
• 16.5 C minőségi kapuk és hibajavítási jegyzőkönyv

17 C záróprojekt: stream-alapú diagnosztikai szolgáltatás

• 17.1 Projektkövetelmény, protokoll és ownership térkép
• 17.2 C könyvtári mag és CLI megvalósítási labor
• 17.3 Nonblocking TCP adapter és leállítás
• 17.4 Záróreview: helyesség, diagnosztika és mérés

18 Modern C, C23 és a C/C++ határ

• 18.1 C23 nyelvi újdonságok és inkompatibilis változások
• 18.2 C23 könyvtár és preprocessor
• 18.3 C és C++: azonos szintaxis, eltérő szemantika
• 18.4 C hordozhatósági audit és freestanding kitekintés

II. rész: Modern C++

19 Átmenet C-ről modern C++-ra

• 19.1 C++ programmodell és zero-overhead elv
• 19.2 Namespace, header és névfeloldás
• 19.3 Reference, pointer és const C++-ban
• 19.4 auto, decltype és típuslevezetés
• 19.5 Overload, konverzió és explicit interfész

20 C++ objektumok, inicializálás és élettartam

• 20.1 Az inicializálás különböző alakjai
• 20.2 Osztály, konstruktor és invariáns
• 20.3 Destruktor és részleges konstrukció
• 20.4 Temporary, value category és dangling
• 20.5 Statikus és thread-local objektumok életciklusa
• 20.6 Tároló újrafelhasználása és C++ objektumszabályok

21 RAII, erőforráskezelés és smart pointerek

• 21.1 new/delete és az allokáció-konstrukció kapcsolat
• 21.2 RAII wrapper file descriptorhoz és lockhoz
• 21.3 unique_ptr és egyedi tulajdonlás
• 21.4 shared_ptr, control block és weak_ptr
• 21.5 Owner, view és erőforrásszerződés C++ API-ban

22 Értékszemantika, másolás és mozgatás

• 22.1 Rule of zero, three és five
• 22.2 Mély másolás, értéktípus és exception guarantee
• 22.3 Move constructor, moved-from állapot és std::move
• 22.4 Copy elision, RVO/NRVO és értékvisszaadás
• 22.5 noexcept, swap és container-reallocation

23 Osztálytervezés, láthatóság és operátorok

• 23.1 public/private/protected és invariánsvédelem
• 23.2 Értéktípus, kompozíció és immutable interfész
• 23.3 Operátortúlterhelés és konverziós operátor
• 23.4 Egyenlőség, spaceship és rendezési kategóriák
• 23.5 Osztály- és operátortervezési labor

24 Öröklés, virtuális függvények és OOP

• 24.1 Öröklés, base subobject és hozzáférés
• 24.2 Virtual, override, final és dispatch
• 24.3 Virtuális destruktor, slicing és ownership
• 24.4 RTTI, dynamic_cast és típusazonosság
• 24.5 Többszörös öröklés és virtuális bázis

25 Kivételek és C++ hibakezelési stratégiák

• 25.1 throw, catch és stack unwinding
• 25.2 No-throw, strong és basic exception guarantee
• 25.3 noexcept határok és hibapolicy
• 25.4 error_code, system_error és expected
• 25.5 Hibakezelési és exception safety labor

26 Template-ek és generikus programozás alapjai

• 26.1 Függvénysablon, instantiation és deduction
• 26.2 Osztálysablon, nem típusparaméter és CTAD
• 26.3 Forwarding reference és perfect forwarding
• 26.4 Specialization, overload és explicit instantiation
• 26.5 Dependent name, kétfázisú lookup és ADL
• 26.6 Generikus interfész és sablondiagnosztikai labor

27 Concepts, type traits és compile-time generikusság

• 27.1 Type traits, tag dispatch és if constexpr
• 27.2 Concepts, requires és constrained overload
• 27.3 SFINAE és örökölt template minták
• 27.4 Variadic template, pack és fold expression
• 27.5 Customization point, CRTP és policy design

28 STL tárolók és érvényességi szerződések

• 28.1 std::array, std::vector és folytonos tárolás
• 28.2 std::string, std::string_view és szövegownership
• 28.3 deque, list és forward_list
• 28.4 map, set és rendezett asszociatív tárolók
• 28.5 unordered tárolók és container adapterek
• 28.6 Tárolóválasztási és invalidációs labor

29 Iteratorok és standard algoritmusok

• 29.1 Iterator-kategóriák és fél-nyílt tartomány
• 29.2 Transform, copy, remove és módosító algoritmusok
• 29.3 Rendezés, keresés és comparator szerződés
• 29.4 Numerikus algoritmusok és kiértékelési sorrend
• 29.5 Execution policy és párhuzamos algoritmusok

30 Lambdák, callable-ek és ranges

• 30.1 Lambda, capture és closure lifetime
• 30.2 invoke, function wrapper és type erasure
• 30.3 Ranges algoritmusok, projection és sentinel
• 30.4 Lazy view pipeline és mellékhatások
• 30.5 Borrowed range, dangling és iterator lifetime
• 30.6 Ranges- és callback-élettartam labor

31 Standard utility típusok és memória-view-k

• 31.1 optional, variant és visit
• 31.2 tuple, pair, any és type erasure
• 31.3 span, byte és bounds-szerződések
• 31.4 Bitműveletek és objektumreprezentáció C++-ban
• 31.5 Multidimenziós view és numeric utility térkép

32 C++ szöveg, fájlok, idő és könyvtári I/O

• 32.1 iostream, stream state és pufferelés
• 32.2 charconv, format és C++23 print
• 32.3 filesystem, path és OS-határ
• 32.4 chrono, duration és időpont
• 32.5 Szövegkódolás, locale és random

33 Compile-time C++, ODR és modulok

• 33.1 constexpr, consteval és constant evaluation
• 33.2 Compile-time adatok és típusos konfiguráció
• 33.3 ODR, inline és több fordítási egység
• 33.4 C++20 modules és header unit
• 33.5 Feature-test, standard library és build capability

34 Modern C++ konkurencia és szinkronizáció

• 34.1 thread, jthread és kooperatív cancellation
• 34.2 RAII lockok, condition variable és wait predicate
• 34.3 C++ atomics, atomic_ref és publication
• 34.4 promise, future, async és task eredmény
• 34.5 semaphore, latch, barrier és szinkron stream
• 34.6 shared ownership, reclamation és konkurens review

35 Coroutine-ok és aszinkron erőforrás-életciklus

• 35.1 Coroutine mint felfüggeszthető állapotgép
• 35.2 promise_type, awaiter és coroutine_handle
• 35.3 Dangling capture, resumption és cancellation
• 35.4 Generator és streaming feldolgozás
• 35.5 Aszinkron I/O adapter és coroutine-labor

36 C++ ABI, C interfész és FFI

• 36.1 Névtorzítás, layout és C++ runtime ABI
• 36.2 extern C és két nyelvű header
• 36.3 Stabil shared library határ és verziózás
• 36.4 Python és más nyelvek FFI-kapcsolata
• 36.5 ABI- és FFI-labor, kompatibilitási teszt

37 Teljesítmény, allocatorok és memóriaelrendezés C++-ban

• 37.1 Allocator model és allocator_traits
• 37.2 pmr, memory_resource és region lifetime
• 37.3 Object layout, EBO és adatközpontú tervezés
• 37.4 Profilozás, benchmark és cost model
• 37.5 Template, virtual és std::function költsége
• 37.6 Optimalizálási labor correctness kapukkal

38 Natív build, tesztek, CI és disztribúció

• 38.1 Build graph, Make/Ninja és incremental build
• 38.2 Modern CMake target-alapú projekt
• 38.3 Függőségek, package discovery és linkhatárok
• 38.4 CTest, negatív tesztek és sanitizer CI
• 38.5 Cross-compilation és multiarch build
• 38.6 Release, debug symbol és reprodukálhatóság

39 C++ záróprojekt: a C rendszer átalakítása

• 39.1 Portterv és azonos viselkedési szerződés
• 39.2 C++ core: parser, erőforrások és értéktípusok
• 39.3 Task, queue és szolgáltatás-életciklus
• 39.4 CMake, tesztek és mérési csomag
• 39.5 Záróreview és C/C++ összehasonlítás

III. rész: C++23 elmélyítés és C++26 kitekintés

40 C++23 nyelvi újdonságok: tagfüggvények, konstans kiértékelés és kifejezések

• 40.1 C++23 laborprofil, szabványstátusz és feature-test
• 40.2 Explicit object parameter: deducing this
• 40.3 static operator(), többdimenziós indexelés és lambdaváltozások
• 40.4 Konstans kiértékelés C++23-ban: if consteval és constexpr bővítések
• 40.5 Érték, élettartam és kifejezések: auto(x), implicit move és range-for
• 40.6 Lexikális és preprocessor bővítések, kiterjesztett lebegőpontos típusok

41 Hibakezelés, diagnosztika és kimenet C++23-ban

• 41.1 std::expected mélyebben: monadikus hibaláncok
• 41.2 optional monadikus műveletei és hibamodellek kompozíciója
• 41.3 std::print, std::println és tartományok formázása
• 41.4 std::stacktrace és futásidejű diagnosztika

42 Ranges C++23-ban: konverzió, új view-k és algoritmusok

• 42.1 ranges::to és tárolókonstrukció range-ből
• 42.2 Kombináló view-k: zip, adjacent, enumerate, cartesian_product
• 42.3 Szeletelő és átalakító view-k: chunk, slide, chunk_by, stride, join_with
• 42.4 C++23 range-algoritmusok és ranges-labor

43 Tárolók, memória és alacsony szintű eszközök C++23-ban

• 43.1 flat_map és flat_set: rendezett tárolás folytonos memóriában
• 43.2 mdspan mélyebben: layoutok, accessorok és C-interop
• 43.3 Callable és forwarding eszközök: move_only_function, forward_like, bind_back
• 43.4 Alacsony szintű és C-interop eszközök C++23-ban

44 Modulok, generátorok és migráció C++23-ra

• 44.1 import std és import std.compat
• 44.2 std::generator mélyebben: rekurzió, allokáció és ranges
• 44.3 Elavult, eltávolított és viselkedést váltó elemek C++23-ban
• 44.4 Migrációs labor: a C++ záróprojekt átállítása C++23-ra

45 Rövid kitekintés: C++26

• 45.1 C++26 nyelvi kitekintés: reflexió, contracts és kisebb újdonságok
• 45.2 C++26 könyvtári és konkurencia-kitekintés

IV. rész: Kitekintés és referencia

46 Haladó irányok, új szabványok és referencia-függelék

• 46.1 C++23 összefoglaló és migrációs táblázat
• 46.2 C++26 és későbbi irányok ellenőrzött státusszal
• 46.3 Freestanding, embedded, kernel és GPU irányok
• 46.4 Standard könyvtári lefedettség és ökoszisztéma-térkép
• 46.5 Hibaminták, döntési táblák és önellenőrző térkép