Enjoy fast, free delivery, exclusive deals, and award-winning movies & TV shows with Prime
Try Prime
and start saving today with fast, free delivery
Amazon Prime includes:
Fast, FREE Delivery is available to Prime members. To join, select "Try Amazon Prime and start saving today with Fast, FREE Delivery" below the Add to Cart button.
Amazon Prime members enjoy:- Cardmembers earn 5% Back at Amazon.com with a Prime Credit Card.
- Unlimited Free Two-Day Delivery
- Instant streaming of thousands of movies and TV episodes with Prime Video
- A Kindle book to borrow for free each month - with no due dates
- Listen to over 2 million songs and hundreds of playlists
- Unlimited photo storage with anywhere access
Important: Your credit card will NOT be charged when you start your free trial or if you cancel during the trial period. If you're happy with Amazon Prime, do nothing. At the end of the free trial, your membership will automatically upgrade to a monthly membership.
Other Sellers on Amazon
& FREE Shipping
91% positive over last 12 months
& FREE Shipping
91% positive over last 12 months
& FREE Shipping
81% positive over last 12 months
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the author
OK
C++ Software Design: Design Principles and Patterns for High-Quality Software 1st Edition
| Price | New from | Used from |
- Kindle
$48.99 Read with our free app - Paperback
$51.96 - $52.056 Used from $40.23 20 New from $45.25
Purchase options and add-ons
Good software design is essential for the success of your project, but designing software is hard to do. You need to have a deep understanding of the consequences of design decisions and a good overview of available design alternatives. With this book, experienced C++ developers will get a thorough, practical, and unparalleled overview of software design with this modern language.
C++ trainer and consultant Klaus Iglberger explains how you can manage dependencies and abstractions, improve changeability and extensibility of software entities, and apply and implement modern design patterns to help you take advantage of today's possibilities. Software design is the most essential aspect of a software project because it impacts the software's most important properties: maintainability, changeability, and extensibility.
- Learn how to evaluate your code with respect to software design
- Understand what software design is, including design goals such as changeability and extensibility
- Explore the advantages and disadvantages of each design approach
- Learn how design patterns help solve problems and express intent
- Choose the right form of a design pattern to get the most out of its advantages
- ISBN-101098113160
- ISBN-13978-1098113162
- Edition1st
- PublisherO'Reilly Media
- Publication date
2022
October 25
- Language
EN
English
- Dimensions
7.0 x 0.8 x 9.0
inches
- Length
435
Pages
Frequently bought together

Similar items that may ship from close to you
From the brand
-
-
Sharing the knowledge of experts
O'Reilly's mission is to change the world by sharing the knowledge of innovators. For over 40 years, we've inspired companies and individuals to do new things (and do them better) by providing the skills and understanding that are necessary for success.
Our customers are hungry to build the innovations that propel the world forward. And we help them do just that.
From the Publisher
From the Preface
Why I Wrote This Book
By the time I was really digging into the language (that was a few years after the first C++ standard had been released), I had read pretty much every C++ book there was. But despite the fact that many of these books were great and definitely paved the way for my current career as a C++ trainer and consultant, they were too focused on the little details and the implementation specifics, and too far away from the bigger picture of maintainable software.
At the time, very few books truly focused on the bigger picture, dealing with the development of large software systems. Among these were John Lakos’s Large Scale C++ Software Design, a great but literally heavy introduction to dependency management, and the so-called Gang of Four book, which is the classic book on software design patterns. Unfortunately, over the years, this situation hasn’t really changed: most books, talks, blogs, etc., primarily focus on language mechanics and features—the small details and specifics. Very few, and in my opinion way too few, new releases focus on maintainable software, changeability, extensibility, and testability. And if they try to, they unfortunately quickly fall back into the common habit of explaining language mechanics and demonstrating features.
This is why I’ve written this book. A book that does not, in contrast to most others, spend time on the mechanics or the many features of the language, but primarily focuses on changeability, extensibility, and testability of software in general. A book that does not pretend that the use of new C++ standards or features will make the difference between good or bad software, but instead clearly shows that it is the management of dependencies that is decisive, that the dependencies in our code decide between it being good or bad. As such, it is a rare kind of book in the world of C++ indeed, as it focuses on the bigger picture: software design.
Who This Book Is For
This book is of value to every C++ developer. In particular, it is for every C++ developer interested in understanding the usual problems of maintainable software and learning about common solutions to these problems (and I assume that is indeed every C++ developer). However, this book is not a C++ beginner’s book. In fact, most of the guidelines in this book require some experience with software development in general and C++ in particular. For instance, I assume that you have a firm grasp of the language mechanics of inheritance hierarchies and some experience with templates. Then I can reach for the corresponding features whenever necessary and appropriate. Once in a while, I will even reach for some C++20 features (in particular C++20 concepts). However, as the focus is on software design, I will rarely dwell on explaining a particular feature, so if a feature is unknown to you, please consult your favorite C++ language reference. Only occasionally will I add some reminders, mostly about common C++ idioms (such as the Rule of 5).
Editorial Reviews
About the Author
Product details
- Publisher : O'Reilly Media; 1st edition (October 25, 2022)
- Language : English
- Paperback : 435 pages
- ISBN-10 : 1098113160
- ISBN-13 : 978-1098113162
- Item Weight : 1.7 pounds
- Dimensions : 7 x 0.75 x 9 inches
- Best Sellers Rank: #207,025 in Books (See Top 100 in Books)
- #33 in C++ Programming Language
- #56 in Object-Oriented Design
- #172 in Software Development (Books)
- Customer Reviews:
Important information
To report an issue with this product, click here.
About the author

Klaus Iglberger is a freelance C++ trainer and consultant. He completed his PhD in Computer Science in 2010 and has subsequently concentrated on large-scale C++ software design. He shares his expertise through popular C++ courses all around the world. He is also the creator and lead designer of the Blaze C++ math library (https://bitbucket.org/blaze-lib/blaze/), one of the organizers of the Munich C++ user group (MUC++) (https://www.meetup.com/MUCplusplus/), and the (co-)organizer of the Back-to-Basics (https://cppcon.org/b2b/) and Software Design (https://cppcon.org/softwaredesign/) tracks at CppCon (https://cppcon.org).
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
I appreciate that design is complicated, and the book gives details about when and why you might use a particular pattern. When designing good software, a lot of your decisions are very dependent on what you’re designing and how you want to implement. Those nuances come through as each pattern is explained in detail.
Finally, the book uses modern C++ standards in its examples, including C++ 20; while also including previous standards as well. I know GoF was the standard in design patterns, but for me this worked well as it is specific to C++.
Klaus Iglberger, an accomplished expert in the field, offers a masterful blend of in-depth knowledge and practical experience, making this book an essential read for both beginners and seasoned developers. His writing is precise, engaging, and insightful, allowing readers to grasp complex concepts effortlessly. With numerous real-world examples and hands-on exercises, the book fosters a deep understanding of modern C++ principles and practices.
"C++ Software Design" covers a wide array of topics that cater to various aspects of software development. Readers will gain a solid foundation in C++ fundamentals, learn advanced language features, and explore libraries and tools to enhance productivity. The book delves into vital topics such as object-oriented programming, design patterns, performance optimization, and error handling, providing the necessary tools to build high-quality software.
One of the standout features of this book is its focus on modern C++ standards, such as C++11, C++14, C++17, and C++20. These updates provide numerous enhancements to the language, enabling developers to create more efficient, maintainable, and powerful applications. Iglberger's thorough explanation of these modern features makes it easy for readers to adopt and implement them in their own projects.
In conclusion, "C++ Software Design" by Klaus Iglberger is a must-read for anyone looking to excel in C++ programming. This comprehensive guide, with its clear writing, real-world examples, and extensive coverage of modern C++ standards, empowers developers to create exceptional software. If you're aiming to stay current with industry trends and deliver high-quality C++ applications, don't miss this invaluable resource!
Primary concepts are (there are more in the form of Guidelines):
Understanding the importance of software design.
Design for change.
Separate interfaces to avoid artificial coupling (the Interface Segregation Principle, see the link above).
Design for Testability.
Design for extension (the Open Closed Principle, see the link above).
Iglberger offers great high-level advice:
Separate concerns
Prefer composition to inheritance
Prefer a non-intrusive design
Prefer value semantics over reference semantics
The book includes great discussions about how to use the classic Gang of Four Design Patterns, both the "old-fashioned" way with virtual hierarchies, and the "modern C++" way using value semantics.
The book is friendly, conversational, and very readable for something about such a complex subject.
Highly recommend.
This is a readable Design Pattern textbook for C++ programmers.
Top reviews from other countries
Non aggiunge molto di nuovo sui vari pattern, però la trattazione è tra le più precise che si possono trovare. C'è sempre una forte discussione su quale contesto sia il migliore in ogni pattern e vengono sempre discussi i possibili contro di certe scelte di design.
Ho apprezzato tanto il formalismo usato nei vari schemi delle diverse architetture presentate, molto efficace dal mio punto di vista.
Lato C++ anche ci sono parecchi pattern di implementazione interessanti, che aggiungono parecchio valore al libro. Molto interessante anche come usa le ultime feature del linguaggio per ridurre le varie dipendenze dei pattern GoF classici.
Quindi mi sento di consigliarlo fortemente, anche se conoscete la maggioranza dei pattern presenti nel libro, visto che molti punti di vista portati dall'autore sono veramente interessanti.
No, design patterns do not take away personality, on the contrary, they transmit wisdom, knowing the problems of a bad design.
If to incorporate something in the software, it is necessary to modify different files, adding things all over the place and crossing our fingers that we have not left something on the way is that someone did not know SOLID and what it means to program for an interface and not for an implementation.
Klaus, who I met him on Youtube at the CppCon (put on youtube "Cppcon klaus") explains in this book --with the same elegance, and that his reading is totally enjoyable as his lectures at the cppcon-- the importance of design (with the added bonus of doing it in our favorite language).
As you read through the book you will smile as step by step Klaus takes you through what good design means, through continuous code improvements, to really understand the design patterns.
If your favorite language is C++, which it probably is, this book is a must buy.
Keep writing Klaus!
Vielen Dank! :)
I find Iglberger’s approach beautifully rigorous ! Type erasure and free functions revolutionized my way of breaking dependencies.
Reading the book is very pleasant, it’s like hearing him lecturing one of these great presentations he does. He has a way of ordering his arguments in a really well organized top-down manner.







