book

Imperfect C++ Practical Solutions for Real-Life Programming

by Matthew Wilson

October 2004

Intermediate to advanced

624 pages

16h 2m

English

Addison-Wesley Professional

Read now

Unlock full access

Dedication
What You Will LearnWhat I Assume You KnowOrganizationReferencesSupplementary MaterialCD-ROMOnline ResourcesAcknowledgments
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
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.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.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.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.1. Vouched Lifetimes5.1.1. Checkout Model5.2. Copied for Caller5.3. Given to Caller5.4. Shared Objects

6.1. Value6.2. State6.3. APIs and Services6.3.1. APIs6.3.2. Services6.4. Language Features
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.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.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.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.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.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
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.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.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.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.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.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
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.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.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.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.1. Hidden Costs23.2. Dangling References23.3. Template Constructor Specialization23.4. Argument Proxies23.5. Argument Targeting23.6. Template Constructors: Coda
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.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.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.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.1. Missing Postfix Operators28.2. Efficiency28.2.1. Detecting Unused Postfix Operators
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
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.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.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.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.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.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.1. Operator OverloadB.2. DRY Rued YesterdayB.3. Paranoid ProgrammingB.4. To Insanity, and Beyond!

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

Chapter 18. Typedefs

The typedef specifier in C and C++ provides a new name for a given type. Two classic uses in C are in removing confusion when using function pointers and reducing typing effort when using structures. Consider the code without typedefs in Listing 18.1.

Example 18.1.

// Info.h
struct Info
{};
int process(int (*)(struct Info*, int*), int*);

// client_code.cpp
int process_forwards(struct Info*, int);
int process_backwards(struct Info*, int);

int main()
{
  struct Info info;
  int (*pfn[10])(struct Info*, int);
  . . .
  for(i = 0; . . .; ++i)
  {
    pfn[i] = . . .

Contrast that with the code in Listing 18.2 that uses structure and function pointer typedefs.

Example 18.2.

// Info.h
typedef struct Info {} Info_t;              // struct typedef
typedef int ...

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.

Start your free trial

Practical C++ Metaprogramming

Edouard Alligand, Joel Falcou

C++ Gotchas: Avoiding Common Problems in Coding and Design

Stephen C. Dewhurst

Exceptional C++ Style 40 New Engineering Puzzles, Programming Problems, and Solutions

Herb Sutter

Practical C++ Design: From Programming to Architecture

Adam B. Singer

Publisher Resources

ISBN: 0321228774Purchase book