Grundkurs C++ (Jürgen Wolf, Martin Guddat) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A compact, chapter-per-topic introduction to modern C++ that takes you from your first program to classes, templates, and exception handling, with exercises and solutions at every step. Best suited to students and self-learners who want a structured, reference-friendly companion rather than a sprawling reference tome. 【Book Arc】 - **Opening (~0%–10%)**: Sets expectations and maps the terrain — the book's philosophy of one topic per chapter, its role as both a linear course and a lookup reference, and a full table of contents that previews the whole journey from "Einstieg in die Welt von C++" through the standard libraries. - **Early (~10%–33%)**: Builds the language floor: built-in data types (integers, characters including the Unicode types, floating point, `auto`, constants), operators and type conversion, control structures (`if`, `switch`, loops, `break`/`continue`), arrays and strings (with `std::vector`, `std::array`, `std::string` alongside C-style variants), and references versus pointers. - **Middle (~33%–52%)**: Moves from single-file scripts to real programs: functions (parameters, overloading, scope, `main`), modularization and the preprocessor (`#include`, `#define`, conditional compilation, header/source separation), namespaces, and specifiers/qualifiers (`static`, `extern`, `constexpr`, `const`, `inline`), then structures, enumerations, and dynamic memory objects. - **Late (~52%–75%)**: The object-oriented core: classes with `public`/`private`, methods, constructors (default, copy, move, delegating, `explicit`), destructors and object lifetime, `inline` and `const` methods, the `this` pointer, objects as parameters and return values, `friend` functions, arrays of objects, dynamic objects, class members as objects, smart pointers as members, and static/const class elements — including a nod to the Rule of Zero. - **Ending (~75%–100%)**: Advanced language features and practical I/O: operator overloading, inheritance and derived classes, templates, exception handling, file input/output streams, and a closing chapter on further language elements and the standard libraries. 【Key Takeaways】 - **One topic per chapter, built for both learning and lookup** (Opening): the editors explicitly frame the book as a compact paperback for readers who want to get to the point quickly, with each subject (data types, classes, templates) isolated in its own chapter so you can jump straight to what you need. - **Exercises and solutions close every chapter** (Early): control questions and tasks act as gatekeepers — the book's own advice is to finish a chapter's exercises before moving on, which makes it a genuine self-study course rather than passive reading. - **Modern C++ is woven in, not bolted on** (Early): `auto`, `nullptr`, `constexpr`, the Unicode character types `char8_t`/`char16_t`/`char32_t`, and move constructors appear alongside the classic material, and the authors flag when a feature requires a particular C++ version. - **Standard library containers come early** (Early): `std::vector`, `std::array`, and `std::string` are introduced next to their C-style counterparts, steering beginners toward safer modern idioms from the start. - **Pointers and references get careful, comparative treatment** (Early): the text covers dereferencing, `nullptr`, pointer checking, and — importantly — when to prefer references or alternatives over raw pointers, a theme that returns later with smart pointers. - **Object lifetime is a first-class topic** (Late): constructors, destructors, copy vs. move semantics, `explicit` to block implicit conversions, and the Rule of Zero are treated as connected design decisions, not isolated syntax. - **From language to program structure** (Middle): the modularization and preprocessor chapter bridges toy examples and real projects — header/source separation, include guards via conditional compilation, namespaces, and linkage specifiers. - **Advanced features arrive in a deliberate order** (Ending): operator overloading, inheritance, templates, exceptions, and file streams cap the course, each in its own chapter so you can study or skip by need. 【Reading Tips】 - **Read linearly if you're new; jump by chapter if you're not.** The book is explicitly designed for both, so use the table of contents as your map and treat each chapter as self-contained. - **Do the exercises before advancing.** The end-of-chapter control questions are the book's built-in progress check; skipping them turns a course into a skim. - **Deep-read the pointer/reference and object-lifetime chapters.** These are where C++ beginners most often stumble, and the book gives them comparative, alternatives-oriented treatment worth slowing down for. - **Skim the C-style material if you already know C.** C-arrays, C-strings, and preprocessor basics are covered for completeness; focus instead on the modern equivalents (`std::vector`, `std::string`, namespaces). - **Keep it as a desk reference after the first pass.** The one-topic-per-chapter structure makes it a quick lookup for syntax and semantics you half-remember. 【Coverage Limits】 The excerpts are dominated by front matter and the table of contents, so this guide maps the book's structure and stated intent rather than the detailed content of individual chapters; specific code examples, exercise difficulty, and depth of treatment of later topics are not covered by the excerpts.