Object-Oriented Software Design in C++, Video Edition

Object-Oriented Software Design in C++, Video Edition

by Ron Mak
Released June 2024
Publisher(s): Manning Publications
ISBN: None

Watch it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Video description

In Video Editions the narrator reads the book while the content, figures, code listings, diagrams, and text appear on the screen. Like an audiobook that you can also watch as a video.

Learn the fundamentals of Object-Oriented design by investigating good—and bad—code!

Well-designed applications run more efficiently, have fewer bugs, and are easier to revise and maintain. Using an engaging “before-and-after” approach, Object-Oriented Software Design in C++ shows you exactly what bad software looks like and how to fix it with good design principles and patterns.

In Object-Oriented Software Design in C++, you’ll find:

  • Design-code-test iterations that improve code with each revision
  • Gathering requirements to make sure you’re developing the right application
  • Design principles like encapsulation and delegation that solve programming problems
  • Design patterns including Observer Design Pattern that fix architecture issues
  • Using recursion and multithreading to simplify common solutions

Object-Oriented Software Design in C++ is a vital guide to building the kind of high performance applications delivered by the pros—all using industry-proven design principles and patterns. You’ll learn how to gather and analyze requirements so you’re building exactly what your client is looking for, backtrack mistakes with iterative development, and build a toolbox of design patterns that troubleshoot common issues with application architecture. The book’s accessible examples are written in C++ 17, but its universal principles can be applied to any object-oriented language.

About the Technology
Good design is the foundation of great software. Mastering the principles of object-oriented design is the surest way to create applications that run fast, have few bugs, and last well into the future. Written especially for new C++ programmers, this easy-to-read book gently mentors you in the art of designing great software.

About the Book
Object-Oriented Software Design in C++ introduces object-oriented design principles, practices, and patterns in clear, jargon-free language. The instantly-familiar before-and-after examples highlight the benefits of good design. Each chapter is full of friendly conversations that anticipate your questions and help point out the subtleties you might overlook. Along the way, you’ll pick up tips about idiomatic C++ style that will set your code apart.

What's Inside
  • Design-code-test iterations
  • Design principles for common programming problems
  • Architecture design patterns in plain English
  • Recursion and multithreading


About the Reader
Examples are in C++ 17.

About the Author
Ronald Mak is a former NASA senior scientist. Currently, he teaches computer science at San Jose State University.

The technical editor on this book was Juan Rufes.

Quotes
It is a joy to see these timeless and pragmatic lessons! If you have basic C++ knowledge, you will become a better programmer by mastering these principles and patterns of object-oriented design.
- Cay Horstmann, author of Core Java and Big C++

Ron Mak has mentored many, many students and through this book you can benefit from his knowledge and experience.
- Dan Harkey, Director of Software Engineering, San Jose State University

Elevate your software design skills with this exceptional guide. A brilliantly crafted masterpiece that goes deep into the art of designing software.
- Eros Pedrini, NTT Data

Table of contents

  1. Part 1. Introduction
  2. Chapter 1. The path to well-designed software
  3. Chapter 1. What you will learn from this book
  4. Chapter 1. The benefits of good software design
  5. Chapter 1. A few design examples
  6. Chapter 1. Make sure we’re going to build the right application; then, build it right
  7. Chapter 1. Good design doesn’t come easily
  8. Chapter 1. Change and complexity are the enemies of good design
  9. Chapter 1. Design with object-oriented programming concepts
  10. Chapter 1. Summary
  11. Chapter 2. Iterate to achieve good design
  12. Chapter 2. Don’t let changes leak out
  13. Chapter 2. Iterate to achieve good design
  14. Chapter 2. Summary
  15. Part 2. Design the right application
  16. Chapter 3. Get requirements to build the right application
  17. Chapter 3. Functional requirements: What must the application do?
  18. Chapter 3. Nonfunctional requirements: Constraints on the application
  19. Chapter 3. What are good requirements?
  20. Chapter 3. How to get requirements
  21. Chapter 3. Unified Modeling Language diagrams for creating and documenting design
  22. Chapter 3. Use cases provide context for the requirements
  23. Chapter 3. The functional specification and software validation
  24. Chapter 3. Where do classes come from?
  25. Chapter 3. Summary
  26. Chapter 4. Good class design to build the application right
  27. Chapter 4. Two important goals for good class design
  28. Chapter 4. UML class diagrams to document class design
  29. Chapter 4. Class relationships determine runtime interactions
  30. Chapter 4. UML state diagram: How an object changes state
  31. Chapter 4. UML sequence diagram: How objects interact [optional]
  32. Chapter 4. The design specification and software verification
  33. Chapter 4. Summary
  34. Part 3. Design the application right
  35. Chapter 5. Hide class implementations
  36. Chapter 5. Public getter and setter functions access hidden implementation selectively
  37. Chapter 5. Class Date: An example of implementation hiding
  38. Chapter 5. Public setter functions carefully modify hidden implementation
  39. Chapter 5. Beware of dangerous setter functions
  40. Chapter 5. Rules from the Law of Demeter
  41. Chapter 5. But is the implementation really hidden?
  42. Chapter 5. The Open-Closed Principle supports code stability
  43. Chapter 5. Summary
  44. Chapter 6. Don’t surprise your users
  45. Chapter 6. Poor performance is an unwelcome surprise
  46. Chapter 6. Programming by Contract helps to eliminate surprises [optional]
  47. Chapter 6. Summary
  48. Chapter 7. Design subclasses right
  49. Chapter 7. The Liskov Substitution Principle and proper subclasses
  50. Chapter 7. Use a factory function with the Code to the Interface Principle
  51. Chapter 7. Programming by Contract with subclasses [optional]
  52. Chapter 7. Summary
  53. Part 4. Design patterns solve application architecture problems
  54. Chapter 8. The Template Method and Strategy Design Patterns
  55. Chapter 8. The Strategy Design Pattern encapsulates algorithms
  56. Chapter 8. Choose between Template Method and Strategy
  57. Chapter 8. Summary
  58. Chapter 9. The Factory Method and Abstract Factory Design Patterns
  59. Chapter 9. The Abstract Factory Design Pattern creates families of objects
  60. Chapter 9. Summary
  61. Chapter 10. The Adapter and Façade Design Patterns
  62. Chapter 10. The Façade Design Pattern hides a subsystem of interfaces
  63. Chapter 10. Summary
  64. Chapter 11. The Iterator and Visitor Design Patterns
  65. Chapter 11. The Visitor Design Pattern encapsulates different algorithms that operate on a data collection
  66. Chapter 11. After using the Visitor Design Pattern
  67. Chapter 11. Summary
  68. Chapter 12. The Observer Design Pattern
  69. Chapter 12. Summary
  70. Chapter 13. The State Design Pattern
  71. Chapter 13. Summary
  72. Chapter 14. The Singleton, Composite, and Decorator Design Patterns
  73. Chapter 14. The Composite Design Pattern treats individual and composite objects uniformly
  74. Chapter 14. The Decorator Design Pattern dynamically adds object responsibilities
  75. Chapter 14. Summary
  76. Part 5. Additional Design Techniques
  77. Chapter 15. Designing solutions with recursion and backtracking
  78. Chapter 15. Finding the largest value by recursion
  79. Chapter 15. Reversing a vector by recursion
  80. Chapter 15. Solve the Towers of Hanoi puzzle by recursion
  81. Chapter 15. Recursive algorithms for a binary search tree
  82. Chapter 15. Quicksort an array with recursion
  83. Chapter 15. The Fibonacci sequence and a recursion disaster
  84. Chapter 15. Dynamic backtracking increases the power of recursion
  85. Chapter 15. Solving the eight queens puzzle with recursion and backtracking
  86. Chapter 15. Solving Sudoku puzzles with recursion and backtracking
  87. Chapter 15. Summary
  88. Chapter 16. Designing multithreaded programs
  89. Chapter 16. A mutex enforces mutual exclusion
  90. Chapter 16. Condition variables synchronize threads
  91. Chapter 16. A final note on multithreading
  92. Chapter 16. Summary

Product information

  • Title: Object-Oriented Software Design in C++, Video Edition
  • Author(s): Ron Mak
  • Release date: June 2024
  • Publisher(s): Manning Publications
  • ISBN: None