liveBookmanning.com

What you will learn in Object-Oriented Software Design in C++

by Ronald Mak

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• lockingMutual exclusion is a synchronization property that restricts access to a protected resource so that only one thread can enter the critical operation at a time.
• recursionA recursive algorithm is an algorithm whose definition or execution invokes the same algorithm on smaller instances of a problem.
• couplingLoose coupling is a design property in which classes have few dependencies on one another's implementations.
• inheritanceInheritance is a language mechanism by which a subclass derives state and behavior from a superclass and may extend or override them.
• AttributesA book-specific class that encapsulates publication attributes and matches them against search targets.
• critical regionA critical region is a section of program execution that accesses a shared resource and must be coordinated to prevent conflicting concurrent operations.
• programming by contractProgramming by contract is a software design technique that specifies preconditions, postconditions, and invariants for program components and may check them during execution.
• functional requirementA documented requirement specifying an operation an application must perform or allow an end user to perform.
• state design patternA behavioral design pattern that encapsulates state-specific behavior in separate objects and delegates behavior according to an object's current state.
• producerA producer is a concurrent software component or thread that creates and enters values into a shared data structure.
• code duplicationCode duplication is the presence of multiple copies of substantially similar implementation logic in a program.
• nonfunctional requirementA requirement that imposes a constraint on an application's qualities, operation, environment, or implementation-independent behavior rather than specifying a discrete feature.
• don't repeat yourself principleThe Don't Repeat Yourself Principle states that every piece of knowledge or behavior should have a single authoritative representation in a system.
• Law of DemeterThe Law of Demeter is a software design principle that limits how much implementation knowledge and object-structure navigation a component exposes or relies upon.
• state transitionA state transition is a change from one object state to another caused by a change in member-variable values.
• treeA hierarchical data structure composed of nodes connected by parent-child relationships without cycles.
• ticket machineA book-specific simulated machine represented by a C++ class that sells tickets in response to customer and machine actions while tracking its operational state.
• backtrackingA backtracking technique that recursively explores alternative solution paths and reverses choices when a path fails.
• visitor design patternThe Visitor Design Pattern is a behavioral design pattern that represents operations over an object structure as separate visitor objects, allowing new operations without changing the structure's element classes.
• requirementsA software requirement is a capability, constraint, or condition that a software system must satisfy.
• open-closed principleA design principle stating that software entities should be closed for modification but open for extension.
• vectorA dynamically sized sequential container that stores elements in contiguous order and manages an internal dynamically allocated array.
• preconditionA design principle stating that a function caller must establish the function's precondition before invoking it.
• condition variableA condition variable is a synchronization primitive on which threads wait for a condition and from which they can be notified when that condition may have changed.
• date classA date class is a book-specific C++ class that represents calendar dates and provides date access and arithmetic operations.
• flexibilitySoftware flexibility is the ease with which a software system can accommodate new features or changed requirements.
• design patternA design pattern is an industry-proven reusable model for solving a recurring software design or architecture problem.
• observer patternA design pattern that defines a one-to-many dependency so observers are notified when a subject changes state.
• encapsulationImplementation hiding is the practice of concealing a class's internal data representation and function implementations behind an accessible interface.
• factoryA class responsible for creating and selecting instances of other classes while hiding construction details from clients.
• superclassA superclass is a class from which a subclass inherits state and behavior.
• BaseballReporterA book-specific C++ class that obtains baseball events and distributes them to multiple report components.
• code to the interface principleA design principle that makes code depend on an interface and polymorphic behavior rather than a specific subclass implementation.
• copy assignment operatorA C++ assignment operator that replaces an existing object's state with a copy of another object of the same or compatible type.
• copy constructorA constructor that initializes a new C++ object from an existing object of the same type.
• readyA book-specific state class representing a ticket machine that is ready for customer interaction.
• sold_outA book-specific state class representing a ticket machine with no tickets available.
• ticket_soldA named ticket-machine state in which the machine has sold a ticket and the customer can take it.
• validatingA named ticket-machine state in which the machine is checking a customer's credit-card validation status.
• favor composition over inheritance principleThe Favor Composition over Inheritance Principle recommends using composition instead of inheritance when composition provides more flexible, encapsulated, less complex, and loosely coupled designs.
• cookbook regionA categorical attribute identifying the culinary region associated with a cookbook.
• sportA book-specific abstract C++ class representing a sport whose player-recruitment and venue-reservation algorithms are defined through abstract operations.
• composite design patternA structural design pattern that represents part-whole hierarchies as tree structures and lets clients treat individual objects and object compositions uniformly.
• strategy design patternThe Strategy Design Pattern is a behavioral design pattern that encapsulates interchangeable algorithms behind a common interface so one can be selected independently of the client that uses it.
• date arithmeticDate arithmetic is the computation of dates and intervals by adding, subtracting, or otherwise manipulating calendar-day values.
• Singleton patternThe Singleton design pattern is a creational design pattern that restricts a class to one instance and provides a controlled access point to it.
• encapsulate what variesEncapsulate What Varies is a design principle that isolates aspects of an application likely to change behind stable boundaries.
• unique_lockA C++ standard library lock-management class that provides exclusive ownership of a mutex and releases that ownership automatically when the lock object is destroyed.
• big threeA C++ class-design rule grouping the destructor, copy constructor, and copy assignment operator as special members that may need coordinated implementation.
• destructorA destructor is a C++ member function that runs when an object is destroyed to release resources and perform cleanup.
• appointmentsA book-specific class that stores appointment dates in a collection and provides operations for accessing and modifying them.
• call by valueA parameter-passing mechanism that initializes a function parameter with a copy of the argument value.
• push_backA standard C++ vector operation that appends an element to the container's end.
• referenceA C++ reference is an alias bound to an existing object or function and used to access it without storing a separate object value.
• postconditionA state that is expected to hold when a use case or function finishes or returns.
• private memberA private member is a program element whose direct access is restricted to its defining class, module, file, or other language-defined scope.
• principleA design principle is a general guideline for structuring software to improve qualities such as flexibility and maintainability.
• circular bufferA fixed-capacity queue implemented with storage whose insertion and removal positions wrap around from the end to the beginning.
• dynamic_castdynamic_cast is a C++ run-time checked cast that converts pointers or references within an inheritance hierarchy and can fail safely for incompatible types.
• CookbookA book model representing a cookbook with attributes that include its culinary region.
• CookbookAttrsA book-specific class representing attributes and matching behavior specialized for cookbooks.
• FictionAttrsA book-specific class representing attributes and matching behavior specialized for fiction books.
• GraphReportA book-specific report class that totals baseball outs and hit types and produces a bar-chart report when the game ends.
• LogReportA book-specific report class that immediately prints the contents of each baseball Event object it receives.
• TableReportA book-specific report class that records per-player baseball outs and hit types and produces a table when the game ends.
• iteratorAn iterator is an abstraction that provides sequential access to elements of a data structure without exposing its representation.
• decorator design patternA structural design pattern that attaches additional responsibilities to an object dynamically through wrapper objects that preserve the wrapped object's interface.
• ToyA book-specific C++ example superclass representing toy objects that may have different concrete subclasses.
• publish/subscribe modelA communication model in which a publisher provides state or event information to one or more subscribers without depending on their specific behavior.
• reader-writer problemThe reader-writer problem is a concurrency coordination problem involving concurrent readers and writers of shared data with potentially conflicting access requirements.
• invariantA design principle stating that a class condition must remain true throughout the runtime of its objects.
• wildcard attributeA search criterion indicating that any value of the corresponding book attribute is acceptable.
• subjectA book-specific C++ superclass that maintains observers and notifies them when published content changes.
• Liskov Substitution PrincipleThe Liskov Substitution Principle states that objects of a subclass should be usable wherever objects of its superclass are expected without violating correctness.
• adapterThe Adapter Design Pattern is a structural design pattern that converts one interface into another interface expected by clients so otherwise incompatible components can work together.
• single responsibility principleA design principle stating that a class should have one major responsibility.
• template method design patternThe Template Method Design Pattern is a behavioral design pattern that defines an algorithm's fixed sequence while allowing subclasses to vary selected steps.
• dependencyA software dependency is a component, resource, or prerequisite on which another software component or operation relies to function or proceed.
• ObserverA book-specific interface whose implementors receive update notifications from a Subject.
• multiple inheritanceMultiple inheritance is inheritance in which a class derives directly from more than one superclass.
• shared_lockA C++ standard library lock-management class that provides shared ownership of a mutex for concurrent readers.
• shared_mutexA C++ standard library synchronization class that supports either exclusive ownership by one thread or shared ownership by multiple threads.
• MapA map is an associative data structure that stores key-value pairs and supports retrieving values by key.
• polymorphismPolymorphism is the ability for an object's behavior to vary according to the concrete subclass of the object being referenced.
• delegation principleA design principle in which one class assigns work to another class whose cohesive responsibilities make it more suitable to perform that work.
• multithreadingMultithreading is the concurrent execution of multiple independently schedulable threads within a program.
• cohesive classA class whose members collectively serve one clear primary responsibility.
• verificationA software quality process comprising verification that implementation conforms to specifications and validation that the resulting system satisfies intended needs.
• actorAn actor is a person, external system, or other entity that interacts with an application in a use case.
• classA class is a programming-language construct that defines a type’s structure or behavior and provides a basis for creating or representing objects.
• defensive programmingA programming technique that validates inputs and guards against invalid states or programming errors.
• name-value pairA name-value pair is a data association in which an identifying name or key corresponds to a value.
• variant typeA discriminated type whose value is one of a specified set of alternative datatypes.
• immutable collectionAn immutable object is an object whose observable state cannot be changed after it is created.
• julian day numberA Julian day number is a numeric count of days elapsed since noon on January 1, 4713 BCE, in the Gregorian calendar, with fractional values representing times between noons.
• quicksortQuicksort is a divide-and-conquer sorting algorithm that partitions an array around a pivot and recursively sorts the resulting subarrays.
• functional specificationA document that describes an application's externally observable purpose, behavior, and requirements without internal implementation details.
• strategyA strategy is an encapsulated algorithm or policy that can be selected as one of multiple interchangeable ways to perform an operation.
• pivotA pivot is an element selected by a partition-based sorting algorithm to divide a sequence into smaller regions.
• subarrayA subarray is a portion of an array treated as a separate sequence of elements for an operation or recursive call.
• abstract factory design patternA creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes.
• function overloadingThe definition of multiple functions with the same name but different parameter lists or signatures in a scope.
• enumA type whose values are restricted to a finite set of named constants.
• object familyAn object family is a set of related objects whose implementations are intended to be created together as a compatible product group.
• facade patternThe Façade Design Pattern is a structural design pattern that provides a unified, simplified interface to a set of subsystem interfaces.
• primary action sequenceThe expected ordered set of interactions that occurs during a use case.
• lazy evaluationThe Lazy Evaluation Principle is a design principle that delays an expensive calculation until its result is needed.
• race conditionA race condition is a concurrency defect in which program behavior depends on the timing or ordering of simultaneous operations.
• context switchingContext switching is the operating-system operation of saving one thread's execution state and restoring another's so execution can move between them.
• well-designed programA software program whose behavior fulfills its intended requirements without surprising users or maintainers.
• black-box testingA testing approach that evaluates software through observable inputs and outputs without examining its internal implementation.
• UML sequence diagramA UML sequence diagram is a UML diagram that represents interactions between participants in time order.
• sustainable applicationA sustainable application is software that remains useful, maintainable, and deployable throughout its operational lifespan.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.