It is not very useful for application developers even STLSoft users.
Extended STL, Volume 1 Collections and Iterators Matthew Wilson
The flow is very good and the important points are explained thoroughly. I also liked the concise tips that are sprinkled throughout the book and highlight key points like: Tip: Check class invariants at the start and end of all public methods, including non-mutating ones, to maximize early detection of overwrites in errant code elsewhere in the process I read the book cover to cover, but in small portions. Towards the middle, I started to skip over the implementation details, because it was too much for me. Wilson's approach is to provide the ultimate performance and expressiveness along with other important properties like modularity, robustness, flexibility and discoverability.
This sometimes leads to libraries that platform-specific. Wilson justifies it by saying that the platforms differences are too great to encapsulate without seriously reducing one or more of the other desirable properties. There are also several high-level libraries that are fully platform-independent and are built on top of the STLSoft libraries.
I dabbled in templates and I'm fairly educated about meta-programming, but I don't think I'll write any STL extensions myself anytime soon.
I'm also looking forward to the next book to see what Wilson is going to unearth. July 6, - Published on Amazon.
Learn IT - Books tags stl - Page 6
This book explains container and iterator concepts very well and applies STL way of programming to different set of problems. It does provide somehow different point of angle to STL programming however in many parts reiterates the things said in the past. Anyway I recommend to the readers who has an interest on advanced STL programming. Go to Amazon. Discover the best of shopping and entertainment with Amazon Prime. Prime members enjoy FREE Delivery on millions of eligible domestic and international items, in addition to exclusive access to movies, TV shows, and more.
Back to top. Get to Know Us. File System Name Handling File System State Operations File System Control Operations Return Types and Error Handling Using the Buffers Collections Adapting the glob API Motivation The glob API Decomposition of the Longhand Version Public Interface Member Variables Flags Construction Size and Element Access Iteration Decomposition of the Shorthand Version Summary Member Types and Constants Iteration and Size Methods Attribute Methods Using Version 1 Iterator Category and Adaptable Member Types Supporting fullPath and absolutePath Alternate Implementations Storing the Elements as a Snapshot Storing the Elements as an Iterator Decomposition of Examples Longhand Version Shorthand Version Reparse Points and Infinite Recursion Sequence Design Exception Agnosticism What, No Shims and Constructor Templates?
File System Enumeration with recls: Coda Enumerating Processes and Modules Collection Characteristics Simple Compositional Implementations Acquiring the Process Identifiers Working without Exception Support Enumerating All Modules on a System Avoiding the System Pseudo Processes The Fibonacci Sequence Fibonacci as an STL Sequence Interface of an Infinite Sequence Put a Contract on It Changing Value Type? Constraining Type Discoverability Failure Defining Finite Bounds Iterators Rule After All?
Constructor-Bound Range Emulating std::vector Design Considerations Design of the Array Adaptor Classes Abstract Manipulation of State Copy-and-Swap Idiom Collection-Interface Composition Pedagogical Approach Template Declaration and Inheritance Applying CRTP Allocator Element Access Methods Size Memory Allocation Optimization Capacity Comparison Modifiers Assignment and swap On the CD A Map of the Environment Planning the Interface Lookup by Name Lookup by Name: Coda Inserting, Updating, and Deleting Values by Name Version 1: Contiguous Iterator Version 2: Bidirectional Iterator Version 3: Snapshot Version 4: Reference-Counted Snapshot Final Iteration Implementation Mutable Snapshot?
Creating the Snapshot Heterogeneous Reference Categories? Traveling Back and Forth on the Z-Plane Prologue Version 1: Forward Iteration Version 2: Bidirectional Iteration Handling External Change Bidirectional Iterator Blues Deadly Double Dereference Reversed Semantics Finalizing the Window Peer Sequences Z-Plane: Coda String Tokenization Tokenization Use Cases Other Tokenization Alternatives IOStreams Selecting Categories Test Drive Single-Character Delimiter Composite String Delimiter Preserving Blanks Copying versus Referencing: Considering Views Character Set Delimiter The Policy Folly Refactoring Template Parameters via Inheritance Type Generator Templates Adapting COM Enumerators COM Enumerators Different Value Types Value Policies Iteration Methods Breaking Value Semantics?
Why an Enumeration Context?
Fler böcker av Matthew Wilson
Class Definition Iterator Support Methods Invariant Iterator Cloning Policies Why Not Default to Forward Iterators? Why Not Default to Input Iterators? Why Not Have a Fixed Quanta of 1? Why Not Use a Standard Container? Coming Next Adapting COM Collections Iteration: Using a Dirty Trick Cleanly Enumerator Acquisition Policies Linearizing with COM Streams Time for Some Cake Specializing the Standard Library Argument-Dependent Return-Type Variance Borrowing a Jewel from Ruby Generalized Compatibility via String Access Shims A Fly in the int-ment Selecting Return Type and Overload Proscribing Signed Subscript Indexes External Iterator Invalidation Element-Interface Coherence Retrieval Races?
Enumerating Registry Keys and Values Handling External Iterator Invalidation On the CD Three. Iterators Shims, Naturally Safe Semantics A Clash of Design Principles?
- Wicked North Alabama.
- Gettysburg: The Confederate High Tide.
- West Coast Cooking.
Defining Stream Insertion Operators Transform Iterator Using std::transform