book

Imperfect C++ Practical Solutions for Real-Life Programming

Name: Imperfect C++ Practical Solutions for Real-Life Programming
Author: Matthew Wilson
ISBN: 9780321228772

by Matthew Wilson

October 2004

Intermediate to advanced

624 pages

16h 2m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Dedication
Preface
What You Will LearnWhat I Assume You KnowOrganizationReferencesSupplementary MaterialCD-ROMOnline ResourcesAcknowledgments
Prologue: Philosophy of the Imperfect Practitioner
C++ Is Not PerfectHairshirt ProgrammingMaking the Compiler Your BatmanNever Say DieThe Spirit of Imperfect C++Coding StyleTerminologyFundamental Types and Compound TypesObject TypesScalar Types and Class TypesAggregatesPOD Types
Imperfections, Constraints, Definitions, and Recommendations
One. Fundamentals
1. Enforcing Design: Constraints, Contracts, and Assertions
1.1. Eggs and Ham1.2. Compile-Time Contracts: Constraints1.2.1. must_have_base()1.2.2. must_be_subscriptable()1.2.3. must_be_subscriptable_as_decayable_pointer()1.2.4. must_be_pod()1.2.5. must_be_same_size()1.2.6. Using Constraints1.2.7. Constraints and TMP1.2.8. Constraints: Coda1.3. Runtime Contracts: Preconditions, Postconditions, and Invariants1.3.1. Preconditions1.3.2. Post-conditions1.3.3. Class Invariants1.3.4. Checking? Invariably!1.3.5. To DbC, or Not to DbC?1.3.6. Runtime Contracts: Coda1.4. Assertions1.4.1. Getting the Message1.4.2. Inappropriate Assertions1.4.3. Syntax and 64-Bit Pointers1.4.4. Avoid verify()1.4.5. Naming Your Assertions1.4.6. Avoid #ifdef _DEBUG1.4.7. DebugAssert() vs int 31.4.8. Static/Compile-Time Assertions1.4.9. Assertions: Coda
2. Object Lifetime
2.1. The Object Life Cycle2.1.1. In-Place Construction2.2. Controlling Your Clients2.2.1. Member Types2.2.2. Default Constructor2.2.3. Copy Constructor2.2.4. Copy Assignment2.2.5. new and delete2.2.6. Virtual Delete2.2.7. explicit2.2.8. Destructor2.2.9. friend2.3. MILs and Boon2.3.1. Getting a Bigger Playpen2.3.2. Member-Ordering Dependencies2.3.3. offsetof()2.3.4. MIL: Coda
3. Resource Encapsulation
3.1. A Taxonomy of Resource Encapsulation3.2. POD Types3.2.1. Direct Manipulation3.2.2. API Functions and Transparent Types3.2.3. API Functions and Opaque Types3.3. Wrapper Proxies3.4. RRID Types3.4.1. Default-Initialized: Lazy Initialization3.4.2. Uninitialized3.5. RAII Types3.5.1. Immutable / Mutable3.5.2. Internally/Externally Initialized3.5.3. RAII Permutations3.6. RAII Coda3.6.1. Invariants3.6.2. Error Handling
4. Data Encapsulation and Value Types
4.1. A Taxonomy of Data Encapsulation4.2. Value Types and Entity Types4.3. A Taxonomy of Value Types4.4. Open Types4.4.1. POD Open Types4.4.2. C++ Data Structures4.5. Encapsulated Types4.6. Value Types4.7. Arithmetic Value Types4.8. Value Types Coda4.9. Encapsulation Coda
5. Object Access Models
5.1. Vouched Lifetimes5.1.1. Checkout Model5.2. Copied for Caller5.3. Given to Caller5.4. Shared Objects

6. Scoping Classes
6.1. Value6.2. State6.3. APIs and Services6.3.1. APIs6.3.2. Services6.4. Language Features
Two. Surviving the Real World
7. ABI
7.1. Sharing Code7.2. C ABI Requirements7.2.1. Structure Layout7.2.2. Calling Conventions, Symbol Names, and Object File Formats7.2.3. Static Linking7.2.4. Dynamic Linking7.3. C++ ABI Requirements7.3.1. Object Layout7.3.2. Virtual Functions7.3.3. Calling Conventions and Mangling7.3.4. Static Linking7.3.5. Dynamic Linking7.4. I Can C Clearly Now7.4.1. extern “C”7.4.2. Namespaces7.4.3. extern “C++”7.4.4. Getting a Handle on C++ Classes7.4.5. Implementation-defined Pitfalls
8. Objects Across Borders
8.1. Mostly Portable vtables?8.1.1. vtable Layouts8.1.2. Dynamic Manipulation of vtables8.2. Portable vtables8.2.1. Simplifying Macros8.2.2. Compatible Compilers8.2.3. Portable Server Objects8.2.4. Simplifying the Implementation of Portable Interfaces8.2.5. C Client Code8.2.6. OAB Constraints8.3. ABI/OAB Coda
9. Dynamic Libraries
9.1. Calling Functions Explicitly9.1.1. Calling C++ Functions Explicitly9.1.2. Breaking C++ Access Control9.2. Indentity: Link Units and Link Space9.2.1. Link Units9.2.2. Link Space9.2.3. Multiple Identities9.3. Lifetime9.4. Versioning9.4.1. Lost Functions9.4.2. Changed Signatures9.4.3. Behavioral Changes9.4.4. Constants9.5. Resource Ownership9.5.1. Shared Pools9.5.2. Return to Callee9.6. Dynamic Libraries: Coda
10. Threading
10.1. Synchronizing Integer Access10.1.1. Operating System Functions10.1.2. Atomic Types10.2. Synchronizing Block Access: Critical Regions10.2.1. Interprocess and Intraprocess Mutexes10.2.2. Spin Mutexes10.3. Atomic Integer Performance10.3.1. Atomic Integer by Mutex10.3.2. Run Time Architecture Dispatching10.3.3. Performance Comparisons10.3.4. Atomic Integer Operations Coda10.4. Multithreading Extensions10.4.1. synchronized10.4.2. Anonymous synchronized10.4.3. atomic10.5. Thread Specific Storage10.5.1. Re-entrancy10.5.2. Thread-Specific Data / Thread-Local Storage10.5.3. __declspec(thread) and TLS10.5.4. The Tss Library10.5.5. TSS Performance
11. Statics
11.1. Nonlocal Static Objects: Globals11.1.1. Intracompilation Unit Ordering11.1.2. Intercompilation Unit Ordering11.1.3. Avoid Globals, in the main()11.1.4. Global Objects Coda: Ordering11.2. Singletons11.2.1. Meyers Singleton11.2.2. Alexandrescu Singleton11.2.3. Just-in-Time Schwarz Counters: A Nifty Idea11.2.4. Counting on APIs11.2.5. Counted APIs, Wrappers, Proxies: Ordered Singletons at Last!11.3. Function-Local Static Objects11.3.1. Sacrifice Lazy Evaluation11.3.2. Spin Mutexes to the Rescue11.4. Static Members11.4.1. Heading Off Linker Issues11.4.2. Adaptive Code11.5. Statics Coda
12. Optimization
12.1. Inline Functions12.1.1. Beware Premature Optimization12.1.2. Header-Only Libraries12.2. Return Value Optimization12.2.1. Named Return Value Optimization12.3. Empty Base Optimization12.4. Empty Derived Optimization12.5. Preventing Optimization
Three. Language Concerns
13. Fundamental Types
13.1. May I Have a byte?13.1.1. Look for a Sign13.1.2. It's All in the Name13.1.3. Peering into the Void13.1.4. Extra Safety13.2. Fixed-Sized Integer Types13.2.1. Platform Independence13.2.2. Type-Specific Behavior13.2.3. Fixed-Sized Integer Types: Coda13.3. Large Integer Types13.4. Dangerous Types13.4.1. References and Temporaries13.4.2. bool
14. Arrays and Pointers
14.1. Don't Repeat Yourself14.2. Arrays Decay into Pointers14.2.1. Subscript Operator Commutativity14.2.2. Preventing Decay14.3. dimensionof()14.4. Cannot Pass Arrays to Functions14.5. Arrays Are Always Passed by Address14.6. Arrays of Inherited Types14.6.1. Store Polymorphic Types by Pointer14.6.2. Provide Nondefault Constructors14.6.3. Hide Vector new and delete14.6.4. Use std::vector14.6.5. Ensure That Types Are the Same Size14.7. Cannot Have Multidimensional Arrays
15. Values
15.1. NULL—The Keyword That Wasn't15.2. Down to Zero15.3. Bending the Truth15.4. Literals15.4.1. Integers15.4.2. Suffixes15.4.3. Strings15.5. Constants15.5.1. Simple Constants15.5.2. Class-Type Constants15.5.3. Member Constants15.5.4. Class-Type Member Constants
16. Keywords
16.1. interface16.1.1. pinterface16.2. temporary16.3. owner16.4. explicit(_cast)16.4.1. Use Explicit Accessor Methods16.4.2. Emulate Explicit Casts16.4.3. Use Attribute Shims16.5. unique16.6. final16.7. Unsupported Keywords16.7.1. typename
17. Syntax
17.1. Class Layout17.2. Conditional Expressions17.2.1. Make It Boolean17.2.2. A Dangerous Assignment17.3. for17.3.1. Initializer Scope17.3.2. Heterogeneous Initializer Types17.4. Variable Notation17.4.1. Hungarian Notation17.4.2. Member Variables
18. Typedefs
18.1. Pointer Typedefs18.2. What's in a Definition?18.2.1. Conceptual Type Definitions18.2.2. Contextual Type Definitions18.3. Aliases18.3.1. Erroneous Conceptual Type Interchange18.3.2. No Overloading on Conceptual type18.4. True Typedefs18.5. The Good, the Bad, and the Ugly18.5.1. Good typedefs18.5.2. Bad Typedefs18.5.3. Dubious Typedefs
Four. Cognizant Conversions
19. Casts
19.1. Implicit Conversion19.2. Casting in C++19.3. The Case for C Casts19.4. Casts on Steroids19.5. explicit_cast19.6. literal_cast19.7. union_cast19.8. comstl::interface_cast19.8.1. interface_cast_addref19.8.2. interface_cast_noaddref19.8.3. interface_cast_test19.8.4. Operator Implementations19.8.5. Protecting the Reference Count19.8.6. interface_cast_base19.8.7. IID_traits19.8.8. interface_cast Coda19.9. boost::polymorphic_cast19.10. Casts: Coda
20. Shims
20.1. Embracing Change and Enhancing Flexibility20.2. Attribute Shims20.3. Logical Shims20.4. Control Shims20.5. Conversion Shims20.6. Composite Shim Concepts20.6.1. Access Shims20.6.2. Return Value Lifetime20.6.3. Generalized Type Manipulation20.6.4. Efficiency Concerns20.7. Namespaces and Koenig Lookup20.8. Why Not Traits?20.9. Structural Conformance20.9.1. Semantic Conformance20.10. Breaking Up the Monolith20.11. Shims: Coda
21. Veneers
21.1. Lightweight RAII21.2. Binding Data and Operations21.2.1. pod_veneer21.2.2. Creating Log Messages21.2.3. Reducing Waste21.2.4. Type-safe Message Classes21.3. Rubbing Up to Concepts21.4. Veneers: Coda
22. Bolt-ins
22.1. Adding Functionality22.2. Skin Selection22.3. Nonvirtual Overriding22.4. Leveraging Scope22.5. Simulated Compile-Time Polymorphism: Reverse Bolt-ins22.6. Parameterized Polymorphic Packaging22.7. Bolt-ins: Coda
23. Template Constructors
23.1. Hidden Costs23.2. Dangling References23.3. Template Constructor Specialization23.4. Argument Proxies23.5. Argument Targeting23.6. Template Constructors: Coda
Five. Operators
24. operator bool()
24.1. operator int() const24.2. operator void *() const24.3. operator bool() const24.4. operator !()—not!24.5. operator boolean const *() const24.6. operator int boolean::*() const24.7. Operating in the Real World24.8. operator!
25. Fast, Non-intrusive String Concatenation
25.1. fast_string_concatenator<>25.1.1. Working with Custom String Classes25.1.2. Tying the Concatenators Together25.1.3. The Concatenator Class25.1.4. Internal Implementation25.2. Performance25.3. Working with Other String Classes25.3.1. Incorporation into Standard Libraries25.3.2. Incorporation into Modifiable Extant Classes25.3.3. Interoperation with Nonmodifiable Classes25.4. Concatenation Seeding25.5. Pathological Bracing25.6. Standardization
26. What's Your Address?
26.1. Can't Get the Real Address26.1.1. STL Containment26.1.2. ATL Wrapper Classes and CAdapt26.1.3. Getting the Real Address26.2. What Actions Are Carried Out during Conversion?26.3. What Do We Return?26.4. What's Your Address: Coda26.4.1. A Sensationalist Backflip!
27. Subscript Operators
27.1. Pointer Conversion versus Subscript Operators27.1.1. Choose Implicit Conversion Operators27.1.2. Choose Subscript Operators27.2. Handling Errors27.2.1. Subscript Operators versus Iterators27.3. Return Value
28. Increment Operators
28.1. Missing Postfix Operators28.2. Efficiency28.2.1. Detecting Unused Postfix Operators
29. Arithmetic Types
29.1. Class Definition29.2. Default Construction29.3. Initialization (Value Construction)29.4. Copy Construction29.5. Assignment29.6. Arithmetic Operators29.7. Comparison Operators29.8. Accessing the Value29.9. sinteger6429.10. Truncations, Promotions, and Tests29.10.1. Truncations29.10.2. Promotions29.10.3. Tests29.11. Arithmetic Types: Coda
30. Short-circuit!
Six. Extending C++
31. Return Value Lifetime
31.1. A Taxonomy of Return Value Lifetime Gotchas31.1.1. Local Variables31.1.2. Local Statics31.1.3. Postdestruction Pointers31.2. Why Return-by-Reference?31.3. Solution 1—integer_to_string<>31.3.1. RVL31.4. Solution 2—TSS31.4.1. __declspec(thread)31.4.2. Win32 TLS31.4.3. Platform-Independent APIs31.4.4. RVL31.5. Solution 3—Extending RVL31.5.1. Solving Intrathread RVL-LS?31.5.2. RVL31.6. Solution 4—Static Array Size Determination31.6.1. RVL31.7. Solution 5—Conversion Shims31.7.1. RVL31.8. Performance31.9. RVL: The Big Win for Garbage Collection31.10. Potential Applications31.11. Return Value Lifetime: Coda
32. Memory
32.1. A Taxonomy of Memory32.1.1. Stack and Static Memory32.1.2. Stack Expansion32.1.3. Heap Memory32.2. The Best of Both Worlds32.2.1. alloca()32.2.2. VLAs32.2.3. auto_buffer<>32.2.4. Using the Template32.2.5. EBO, Where Art Thou?32.2.6. Performance32.2.7. Heap vs. Stack vs. . . .32.2.8. pod_vector<>32.3. Allocators32.3.1. Function Pointers32.3.2. Allocator Interfaces32.3.3. Per-library Initialization32.3.4. Per-Call Specification32.4. Memory: Coda
33. Multidimensional Arrays
33.1. Facilitating Subscript Syntax33.2. Sized at Run Time33.2.1. Variable Length Arrays33.2.2. vector< ... vector<T> ... >33.2.3. boost::multi_array33.2.4. fixed_array_1/2/3/4d33.3. Sized at Compile Time33.3.1. boost::array33.3.2. static_array_1/2/3/4d33.4. Block Access33.4.1. Using std::fill_n()33.4.2. array_size Shim33.5. Performance33.5.1. Sized at Run Time33.5.2. Sized at Compile Time33.6. Multidimensional Arrays: Coda
34. Functors and Ranges
34.1. Syntactic Clutter34.2. for_all() ?34.2.1. arrays34.2.2. Naming Concerns34.3. Local Functors34.3.1. Unrolled Loops34.3.2. Custom Functors34.3.3. Nested Functors34.3.4. Legally Bland34.3.5. Generalized Functors: Type Tunnelling34.3.6. A Step too Far, Followed by a Sure Step Beyond34.3.7. Local Functors and Callback APIs34.4. Ranges34.4.1. The Range Concept34.4.2. Notional Range34.4.3. Iterable Range34.4.4. Range Algorithms and Tags34.4.5. Filters34.4.6. Hypocrisy?34.5. Functors and Ranges: Coda
35. Properties
35.1. Compiler Extensions35.2. Implementation Options35.2.1. A Taxonomy of Property Implementation Options35.2.2. EMO?35.3. Field Properties35.3.1. field_property_get35.3.2. field_property_set35.3.3. Internal Fields Properties: Coda35.3.4. field_property_get_external35.3.5. field_property_set_external35.3.6. Hacking Away35.4. Method Properties35.4.1. method_property_get35.4.2. method_property_set35.4.3. method_property_getset35.4.4. Loop the Loop!35.4.5. method_property_get_external35.4.6. method_property_set_external35.4.7. method_property_getset_external35.5. Static Properties35.5.1. Static Field Properties35.5.2. Internal Static Method Properties35.5.3. External Static Method Properties35.6. Virtual Properties35.7. Property Uses35.7.1. Genericity35.7.2. Type Substitution for Diagnostics35.8. Properties: Coda
A. Compilers and Libraries
A.1. CompilersA.1.1. Compiler OptimizationsA.2. LibrariesA.2.1. BoostA.2.2. STLSoftA.2.3. OthersA.3. Other ResourcesA.3.1. JournalsA.3.2. Other LanguagesA.3.3. Newsgroups
B. “Watch That Hubris!”
B.1. Operator OverloadB.2. DRY Rued YesterdayB.3. Paranoid ProgrammingB.4. To Insanity, and Beyond!
C. Arturius
D. The CD
Epilogue
Bibliography

Content preview from Imperfect C++ Practical Solutions for Real-Life Programming

Chapter 26. What's Your Address?

	Programmers who overload unary operator& should be sentenced to writing libraries that need to operate properly when fed such classes.
	--Peter Dimov, esteemed Boost member, Boost newsgroup June 2002

Although that's very funny, it's also a pretty strong statement. Why is there such antipathy to the use of this operator?

In this chapter we look at some of the problems that overloading operator &() can cause. Our solution will be an unexciting one, simply the recommendation that you follow Peter's implicit advice, forswear any use of this overload for shortsighted gains, and avoid much grief down the line.

One thing I should make clear. Anytime in this chapter that I refer to operator &() it will be the unary form, ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0321228774Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Imperfect C++ Practical Solutions for Real-Life Programming

by Matthew Wilson

Chapter 26. What's Your Address?

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.