Learn Qt 5 Build modern, responsive cross-platform desktop applications with Qt, C++, and QML (Nicholas Sherriff)（Z-Library）

# Learn Qt 5 — Reading Guide ## 【One-Line Pitch】 A hands-on, project-driven guide that walks you through building a complete line-of-business desktop application with Qt 5, C++, and QML — ideal for developers who want to write once and deploy across Windows, macOS, and Linux without sacrificing code quality or testability. ## 【Book Arc】 - **Opening (~0%–9%)**: Installation and configuration of the Qt Framework and Qt Creator IDE, including understanding kits, compilers, and the licensing landscape. Sets up the "scratchpad" project to demystify what a Qt project really is. - **Early (~9%–27%)**: Project structure fundamentals — creating a multi-project solution with QMake, separating business logic (cm-lib), UI (cm-ui), and tests (cm-tests). Introduces the MVC pattern and why physical segregation of concerns matters. - **Middle (~27%–48%)**: Deep dive into QML for building the user interface — views, StackView navigation, anchors, sizing, and styling with shared resources and reusable components. Also covers the C++ side with namespaced controller classes. - **Middle (~48%–60%)**: Data layer implementation — JSON serialization, self-aware data entities, data decorators, entity collections, and custom data models. This is the "brain" of the LOB application. - **Late (~60%–80%)**: Unit testing with QtTest, SQLite persistence with CRUD operations, and web requests to consume live RSS feeds — the practical infrastructure every real application needs. - **Ending (~80%–100%)**: Packaging and deployment — object factories, UI scaling, dashboard design, enumerator selectors, and platform-specific deployment for OS X, Linux, and Windows using the Qt Installer Framework. ## 【Key Takeaways】 - **Kits are the key to cross-platform builds** (Early): A kit bundles Qt binaries with a specific compiler/linker for a target architecture. Understanding kits — and that they don't include compilers — saves hours of confusion when projects won't build. - **A Qt project is just text files** (Early): The scratchpad exercise proves you can create a working project with nothing but a .pro file and a few source files. This demystifies the IDE and empowers manual fixes when tools misbehave. - **MVC with physical separation scales** (Early): By putting business logic in a C++ library, UI in QML, and tests in a separate project, you enable parallel work (UX specialists vs. programmers) and can swap interfaces without touching logic. - **QML is JSON-like and declarative** (Middle): QML's hierarchical syntax with inline JavaScript binds to C++ objects via Qt's meta-object system. It's HTML/XAML-like but without XML verbosity — a relief for JSON fans. - **Resource prefixes keep QML organized** (Middle): Using meaningful prefixes like `/views` instead of `/` in .qrc files prevents URL confusion (e.g., `qrc:/views/views/main.qml`) and keeps the project navigable as files multiply. - **Namespace discipline aids navigation** (Middle): Wrapping classes in project-root and physical-path namespaces (e.g., `cm::controllers`) creates collapsible regions in the IDE, making large files easier to manage — a stylistic choice with real ergonomic payoff. - **Unit testing is non-negotiable in business environments** (Late): QtTest integration is straightforward, and the book's custom approach (beyond Qt's defaults) shows how to test data decorators and entities properly — expect to write tests alongside code. ## 【Reading Tips】 - **Skim the installation chapter** (~0%–9%) if you've already got Qt working; the kit/compiler explanation is worth a quick read, but the step-by-step installer walkthrough is only essential for first-timers. - **Deep-read the MVC and project structure chapters** (~9%–27%): This is where the book's philosophy crystallizes. Understanding why the three-project split exists will make every later chapter click into place. - **The QML chapters (~27%–48%) reward hands-on practice**: Don't just read — modify the MasterView, experiment with StackView navigation, and break things. QML's declarative nature means visual feedback is immediate. - **Watch for the "unorthodox" style choices** (like namespace-wrapped implementation files): The author acknowledges alternatives, so adopt what works for you rather than treating every convention as gospel. - **The final deployment chapter (~80%–100%) is skimmable until you actually ship**: Note the platform-specific gotchas (especially Linux executable permissions), but don't memorize the Installer Framework details until you need them. ## 【Coverage Limits】 The excerpts cover the book's structure, installation, project setup, MVC principles, QML basics, and namespace conventions in detail. Specific code implementations for JSON serialization, SQLite CRUD, RSS consumption, and deployment packaging are referenced but not fully detailed in the available material. ##