Exercices en langage C++ 150 exercices corrigés (Noire) (French Edition) (Claude Delannoy [Delannoy, Claude])（Z-Library）

【One-Line Pitch】 A hands-on C++ exercise book for programmers who already know C and want to internalize object-oriented C++ by building real classes—sets, dynamic vectors, linked lists, stacks, and complex numbers—through 150 corrected problems. Best for self-learners who prefer learning by doing rather than reading theory. 【Book Arc】 - **Opening (~0%–10%)**: Establishes the book's structure—each chapter opens with a detailed refresher, then exercises ranging from immediate application to full class implementations. Early exercises cover type conversions, control instructions, and C-style strings, solving the problem of bridging C knowledge to C++ syntax. - **Early (~10%–30%)**: Moves into functions (argument passing by value/reference, default arguments, overloading, ambiguity resolution) and structures, then enters the core OOP material: class declaration, public/private encapsulation, and the C-to-C++ transition chapter explicitly aimed at C programmers. - **Middle (~30%–50%)**: Deepens object lifecycle concerns—constructors, destructors, static members, dynamic object arrays, member objects, and the `this` pointer. Exercises like the numbered-point class and linked-list set implementation teach memory management and interface stability. - **Late (~50%–70%)**: Covers operator overloading (member vs. friend functions), user-defined type conversions, and inheritance with virtual functions—the mechanisms that make C++ classes behave like built-in types and support polymorphism. - **Ending (~70%–100%)**: Addresses I/O streams, function and class templates, exception handling, and a synthesis chapter (Chapter 20) plus standard components (Chapter 21) that revisits earlier exercises with library facilities. The progression builds increasingly realistic, reusable classes. 【Key Takeaways】 - **Each chapter's refresher is a compressed reference** (Early): The book assumes you'll read the summary before attempting exercises, making it self-contained for C programmers but not a substitute for a full course. - **Exercises escalate from syntax drills to complete class designs** (Early–Middle): You start with type-conversion puzzles and end building sets, dynamic multi-dimensional arrays, linked lists, bit arrays, stacks, and complex numbers. - **Solutions are more than code listings** (Middle): The book emphasizes that a program is one possible rendering among others, so corrections explain reasoning and alternatives—valuable for learning design judgment. - **Memory management is a recurring theme** (Middle): Dynamic objects, `new`/`delete`, destructors freeing linked-list nodes, and the dangers of returning addresses of automatic objects are repeatedly exercised. - **Interface stability matters** (Middle): The set class is reimplemented from array-based to linked-list-based without changing its public interface, teaching separation of interface and implementation. - **Operator overloading can be done as member or friend functions** (Late): The `==` and `!=` exercises for `vecteur3d` show both approaches, highlighting trade-offs in access and symmetry. - **Static members enable class-level state** (Middle): The point-numbering exercise uses a static counter to assign unique IDs, illustrating initialization requirements and shared state. - **The C-to-C++ chapter is a designated entry point** (Early): C programmers should start there; others can skip it, making the book adaptable to different backgrounds. 【Reading Tips】 - **Skim the refreshers if you're already comfortable** with a topic, but deep-read them for chapters on constructors/destructors, operator overloading, and inheritance—these are where C programmers stumble. - **Attempt exercises before reading corrections**, especially the class-design ones; the value is in struggling with interface decisions and memory management. - **Pay attention to the "dissymmetry" notes** (e.g., `.` vs `->`) and ambiguity examples—they encode practical pitfalls that compilers won't always flag clearly. - **Use Chapter 6 as your starting point if you know C**, then loop back to earlier chapters only for topics you find shaky. - **Treat Chapter 20 (synthesis) and Chapter 21 (standard components) as review checkpoints**—they revisit earlier exercises with library facilities, showing how standard containers and algorithms simplify manual implementations. 【Coverage Limits】 The excerpts cover the book's structure, early-to-middle exercises, and some late topics, but do not include detailed content from the inheritance, virtual functions, templates, exception handling, or I/O stream chapters beyond their listing in the table of contents. Specific exercise numbers and full solutions for those chapters are not represented.