Professional C++

【实例截图】

【核心代码】

Contents
Introduction xxi
Who This Book Is For xxi
What This Book Covers xxi
How This Book Is Structured xxii
What You Need to Use This Book xxiii
Conventions xxiii
Source Code xxiv
Errata xxiv
p2p.wrox.com xxiv
Part I: Introduction to Professional C
Chapter 1: A Crash Course in C 1
The Basics of C 1
The Obligatory Hello, World 2
Namespaces 4
Variables 6
Operators 8
Types 10
Conditionals 12
Loops 14
Arrays 15
Functions 16
Those Are the Basics 17
Diving Deeper into C 18
Pointers and Dynamic Memory 18
Strings in C 21
References 23
Exceptions 23
The Many Uses of const 25
C as an Object-Oriented Language 26
Declaring a Class 26
Your First Useful C Program 29
An Employee Records System 29
The Employee Class 29
vi
Contents
The Database Class 34
The User Interface 38
Evaluating the Program 41
Summary 41
Chapter 2: Designing Professional C Programs 43
What Is Programming Design? 44
The Importance of Programming Design 44
What’s Different about C Design? 46
Two Rules for C Design 47
Abstraction 47
Reuse 49
Designing a Chess Program 50
Requirements 51
Design Steps 51
Summary 56
Chapter 3: Designing with Objects 57
An Object-Oriented View of the World 57
Am I Thinking Procedurally? 57
The Object-Oriented Philosophy 58
Living in a World of Objects 61
Object Relationships 63
Abstraction 73
Summary 76
Chapter 4: Designing with Libraries and Patterns 77
Reusing Code 77
A Note on Terminology 78
Deciding Whether or Not to Reuse Code 78
Strategies for Reusing Code 81
Bundling Third-Party Applications 85
Open-Source Libraries 86
The C Standard Library 87
Designing with Patterns and Techniques 101
Design Techniques 101
Design Patterns 102
Summary 103
vii
Contents
Chapter 5: Designing for Reuse 105
The Reuse Philosophy 106
How to Design Reusable Code 106
Use Abstraction 107
Structure Your Code for Optimal Reuse 108
Design Usable Interfaces 112
Reconciling Generality and Ease of Use 117
Summary 118
Chapter 6: Maximizing Software-Engineering Methods 119
The Need for Process 119
Software Life-Cycle Models 120
The Stagewise and Waterfall Models 121
The Spiral Method 123
The Rational Unified Process 126
Software-Engineering Methodologies 127
Extreme Programming (XP) 128
Software Triage 132
Building Your Own Process and Methodology 132
Be Open to New Ideas 132
Bring New Ideas to the Table 132
Recognize What Works and What Doesn’t Work 133
Don’t Be a Renegade 133
Summary 133
Part II: C Coding the Professional Way
Chapter 7: Coding with Style 135
The Importance of Looking Good 135
Thinking Ahead 135
Keeping It Clear 136
Elements of Good Style 136
Documenting Your Code 136
Reasons to Write Comments 136
Commenting Styles 140
Comments in This Book 145
viii
Contents
Decomposition 145
Decomposition through Refactoring 147
Decomposition by Design 147
Decomposition in This Book 148
Naming 148
Choosing a Good Name 148
Naming Conventions 148
Using Language Features with Style 151
Use Constants 151
Take Advantage of const Variables 151
Use References Instead of Pointers 151
Use Custom Exceptions 152
Formatting 152
The Curly Brace Alignment Debate 153
Coming to Blows over Spaces and Parentheses 154
Spaces and Tabs 154
Stylistic Challenges 155
Summary 155
Chapter 8: Gaining Proficiency with Classes and Objects 157
Introducing the Spreadsheet Example 157
Writing Classes 158
Class Definitions 158
Defining Methods 161
Using Objects 164
Object Life Cycles 165
Object Creation 165
Object Destruction 176
Assigning to Objects 177
Distinguishing Copying from Assignment 180
Summary 182
Chapter 9: Mastering Classes and Objects 183
Dynamic Memory Allocation in Objects 183
The Spreadsheet Class 184
Freeing Memory with Destructors 186
Handling Copying and Assignment 186
Different Kinds of Data Members 194
Static Data Members 195
Const Data Members 196
Reference Data Members 198
Const Reference Data Members 199
ix
Contents
More about Methods 199
Static Methods 199
Const Methods 200
Method Overloading 202
Default Parameters 203
Inline Methods 204
Nested Classes 206
Friends 208
Operator Overloading 209
Implementing Addition 209
Overloading Arithmetic Operators 212
Overloading Comparison Operators 215
Building Types with Operator Overloading 216
Pointers to Methods and Members 217
Building Abstract Classes 218
Using Interface and Implementation Classes 218
Summary 221
Chapter 10: Discovering Inheritance Techniques 223
Building Classes with Inheritance 224
Extending Classes 224
Overriding Methods 227
Inheritance for Reuse 230
The WeatherPrediction Class 230
Adding Functionality in a Subclass 231
Replacing Functionality in a Subclass 233
Respect Your Parents 234
Parent Constructors 234
Parent Destructors 235
Referring to Parent Data 237
Casting Up and Down 239
Inheritance for Polymorphism 240
Return of the Spreadsheet 240
Designing the Polymorphic Spreadsheet Cell 241
The Spreadsheet Cell Base Class 242
The Individual Subclasses 243
Leveraging Polymorphism 245
Future Considerations 246
Multiple Inheritance 248
Inheriting from Multiple Classes 248
Naming Collisions and Ambiguous Base Classes 249
x
Contents
Interesting and Obscure Inheritance Issues 253
Changing the Overridden Method’s Characteristics 253
Special Cases in Overriding Methods 256
Copy Constructors and the Equals Operator 263
The Truth about Virtual 264
Runtime Type Facilities 267
Non-Public Inheritance 269
Virtual Base Classes 269
Summary 270
Chapter 11: Writing Generic Code with Templates 271
Overview of Templates 272
Class Templates 273
Writing a Class Template 273
How the Compiler Processes Templates 280
Distributing Template Code between Files 281
Template Parameters 282
Method Templates 285
Template Class Specialization 290
Subclassing Template Classes 293
Inheritance versus Specialization 295
Function Templates 295
Function Template Specialization 296
Function Template Overloading 297
Friend Function Templates of Class Templates 298
Advanced Templates 299
More about Template Parameters 299
Template Class Partial Specialization 307
Emulating Function Partial Specialization with Overloading 313
Template Recursion 314
Summary 322
Chapter 12: Understanding C Quirks and Oddities 323
References 323
Reference Variables 324
Reference Data Members 326
Reference Parameters 326
Reference Return Values 327
Deciding between References and Pointers 327
xi
Contents
Keyword Confusion 330
The const Keyword 330
The static Keyword 333
Order of Initialization of Nonlocal Variables 336
Types and Casts 337
typedefs 337
Casts 338
Scope Resolution 343
Header Files 343
C Utilities 345
Variable-Length Argument Lists 345
Preprocessor Macros 347
Summary 348
Part III: Mastering Advanced Features of C
Chapter 13: Effective Memory Management 349
Working with Dynamic Memory 349
How to Picture Memory 350
Allocation and Deallocation 351
Arrays 353
Working with Pointers 360
Array-Pointer Duality 362
Arrays Are Pointers! 363
Not All Pointers Are Arrays! 364
Dynamic Strings 365
C-Style Strings 365
String Literals 366
The C string Class 367
Low-Level Memory Operations 369
Pointer Arithmetic 369
Custom Memory Management 370
Garbage Collection 370
Object Pools 371
Function Pointers 372
Common Memory Pitfalls 374
Underallocating Strings 374
Memory Leaks 374
Double-Deleting and Invalid Pointers 377
Accessing Out-of-Bounds Memory 378
Summary 378
xii
Contents
Chapter 14: Demystifying C I/O 379
Using Streams 379
What Is a Stream, Anyway? 380
Stream Sources and Destinations 380
Output with Streams 380
Input with Streams 384
Input and Output with Objects 389
String Streams 390
File Streams 392
Jumping around with seek() and tell() 392
Linking Streams Together 395
Bidirectional I/O 396
Internationalization 397
Wide Characters 397
Non-Western Character Sets 398
Locales and Facets 398
Summary 400
Chapter 15: Handling Errors 401
Errors and Exceptions 402
What Are Exceptions, Anyway? 402
Why Exceptions in C Are a Good Thing 403
Why Exceptions in C Are a Bad Thing 404
Our Recommendation 404
Exception Mechanics 404
Throwing and Catching Exceptions 405
Exception Types 406
Throwing and Catching Multiple Exceptions 408
Uncaught Exceptions 411
Throw Lists 412
Exceptions and Polymorphism 416
The Standard Exception Hierarchy 416
Catching Exceptions in a Class Hierarchy 417
Writing Your Own Exception Classes 419
Stack Unwinding and Cleanup 422
Catch, Cleanup, and Rethrow 423
Use Smart Pointers 424
xiii
Contents
Common Error-Handling Issues 424
Memory Allocation Errors 424
Errors in Constructors 427
Errors in Destructors 428
Putting It All Together 428
Summary 430
Part IV: Ensuring Bug-Free Code
Chapter 16: Overloading C Operators 431
Overview of Operator Overloading 432
Why Overload Operators? 432
Limitations to Operator Overloading 432
Choices in Operator Overloading 433
Operators You Shouldn’t Overload 435
Summary of Overloadable Operators 435
Overloading the Arithmetic Operators 438
Overloading Unary Minus and Unary Plus 438
Overloading Increment and Decrement 439
Overloading the Bitwise and Binary Logical Operators 441
Overloading the Insertion and Extraction Operators 441
Overloading the Subscripting Operator 443
Providing Read-Only Access with operator[] 446
Non-Integral Array Indices 447
Overloading the Function Call Operator 448
Overloading the Dereferencing Operators 449
Implementing operator* 451
Implementing operator-> 452
What in the World Is operator->* ? 452
Writing Conversion Operators 453
Ambiguity Problems with Conversion Operators 454
Conversions for Boolean Expressions 455
Overloading the Memory Allocation and Deallocation Operators 457
How new and delete Really Work 457
Overloading operator new and operator delete 459
Overloading operator new and operator delete with Extra Parameters 461
Summary 463
xiv
Contents
Chapter 17: Writing Efficient C 465
Overview of Performance and Efficiency 465
Two Approaches to Efficiency 466
Two Kinds of Programs 466
Is C an Inefficient Language? 466
Language-Level Efficiency 467
Handle Objects Efficiently 467
Don’t Overuse Costly Language Features 471
Use Inline Methods and Functions 472
Design-Level Efficiency 472
Cache as Much as Possible 472
Use Object Pools 473
Use Thread Pools 479
Profiling 479
Profiling Example with gprof 479
Summary 488
Chapter 18: Developing Cross-Platform and Cross-Language Applications 489
Cross-Platform Development 489
Architecture Issues 490
Implementation Issues 492
Platform-Specific Features 493
Cross-Language Development 494
Mixing C and C 494
Shifting Paradigms 495
Linking with C Code 498
Mixing Java and C with JNI 499
Mixing C with Perl and Shell Scripts 501
Mixing C with Assembly Code 504
Summary 505
Chapter 19: Becoming Adept at Testing 507
Quality Control 507
Whose Responsibility Is Testing? 508
The Life Cycle of a Bug 508
Bug-Tracking Tools 509
Unit Testing 510
Approaches to Unit Testing 511
The Unit Testing Process 512
Unit Testing in Action 515
xv
Contents
Higher-Level Testing 523
Integration Tests 523
System Tests 525
Regression Tests 525
Tips for Successful Testing 526
Summary 526
Chapter 20: Conquering Debugging 527
The Fundamental Law of Debugging 527
Bug Taxonomies 528
Avoiding Bugs 528
Planning for Bugs 528
Error Logging 528
Debug Traces 530
Asserts 540
Debugging Techniques 541
Reproducing Bugs 541
Debugging Reproducible Bugs 542
Debugging Nonreproducible Bugs 543
Debugging Memory Problems 544
Debugging Multithreaded Programs 547
Debugging Example: Article Citations 548
Lessons from the ArticleCitations Example 559
Summary 559
Chapter 21: Delving into the STL: Containers and Iterators 561
Containers Overview 562
Requirements on Elements 562
Exceptions and Error Checking 563
Iterators 564
Sequential Containers 565
Vector 566
The vector<bool> Specialization 583
deque 584
list 584
Container Adapters 588
queue 588
priority_queue 591
stack 594
xvi
Contents
Associative Containers 595
The pair Utility Class 595
map 596
multimap 604
set 608
multiset 610
Other Containers 611
Arrays as STL Containers 611
Strings as STL Containers 612
Streams as STL Containers 613
bitset 613
Summary 618
Part V: Using Libraries and Patterns
Chapter 22: Mastering STL Algorithms and Function Objects 619
Overview of Algorithms 620
The find() and find_if() Algorithms 620
The accumulate() Algorithms 623
Function Objects 624
Arithmetic Function Objects 624
Comparison Function Objects 625
Logical Function Objects 627
Function Object Adapters 627
Writing Your Own Function Objects 630
Algorithm Details 631
Utility Algorithms 632
Nonmodifying Algorithms 633
Modifying Algorithms 639
Sorting Algorithms 643
Set Algorithms 646
Algorithms and Function Objects Example: Auditing Voter Registrations 648
The Voter Registration Audit Problem Statement 648
The auditVoterRolls() Function 648
The getDuplicates() Function 649
The RemoveNames Functor 650
The NameInList Functor 651
Testing the auditVoterRolls() Function 652
Summary 653
xvii
Contents
Chapter 23: Customizing and Extending the STL 655
Allocators 656
Iterator Adapters 656
Reverse Iterators 656
Stream Iterators 657
Insert Iterators 658
Extending the STL 660
Why Extend the STL? 660
Writing an STL Algorithm 660
Writing an STL Container 662
Summary 691
Chapter 24: Exploring Distributed Objects 693
The Appeal of Distributed Computing 693
Distribution for Scalability 693
Distribution for Reliability 694
Distribution for Centrality 694
Distributed Content 695
Distributed versus Networked 695
Distributed Objects 696
Serialization and Marshalling 696
Remote Procedure Calls 700
CORBA 702
Interface Definition Language 702
Implementing the Class 704
Using the Objects 706
XML 709
A Crash Course in XML 709
XML as a Distributed Object Technology 712
Generating and Parsing XML in C 712
XML Validation 721
Building a Distributed Object with XML 723
SOAP (Simple Object Access Protocol) 726
Summary 728
Chapter 25: Incorporating Techniques and Frameworks 729
“I Can Never Remember How to . . .” 730
. . . Write a Class 730
. . . Subclass an Existing Class 731
xviii
Contents
. . . Throw and Catch Exceptions 732
. . . Read from a File 733
. . . Write to a File 734
. . . Write a Template Class 734
There Must Be a Better Way 736
Smart Pointers with Reference Counting 736
Double Dispatch 741
Mix-In Classes 747
Object-Oriented Frameworks 750
Working with Frameworks 750
The Model-View-Controller Paradigm 750
Summary 752
Chapter 26: Applying Design Patterns 753
The Singleton Pattern 754
Example: A Logging Mechanism 754
Implementation of a Singleton 754
Using a Singleton 759
The Factory Pattern 760
Example: A Car Factory Simulation 760
Implementation of a Factory 762
Using a Factory 764
Other Uses of Factories 766
The Proxy Pattern 766
Example: Hiding Network Connectivity Issues 766
Implementation of a Proxy 767
Using a Proxy 767
The Adapter Pattern 768
Example: Adapting an XML Library 768
Implementation of an Adapter 768
Using an Adapter 772
The Decorator Pattern 773
Example: Defining Styles in Web Pages 773
Implementation of a Decorator 774
Using a Decorator 775
The Chain of Responsibility Pattern 776
Example: Event Handling 776
Implementation of a Chain of Responsibility 777
Using a Chain of Responsibility 778
xix
Contents
The Observer Pattern 778
Example: Event Handling 778
Implementation of an Observer 778
Using an Observer 780
Summary 781
Appendix A: C Interviews 783
Chapter 1: A Crash Course in C 783
Chapter 2: Designing Professional C Programs 784
Chapter 3: Designing with Objects 785
Chapter 4: Designing with Libraries and Patterns 786
Chapter 5: Designing for Reuse 787
Chapter 6: Maximizing Software Engineering Methods 787
Chapter 7: Coding with Style 788
Chapters 8 and 9: Classes and Objects 789
Chapter 10: Discovering Inheritance Techniques 792
Chapter 11: Writing Generic Code with Templates 793
Chapter 12: Understanding C Quirks and Oddities 793
Chapter 13: Effective Memory Management 794
Chapter 14: Demystifying C I/O 795
Chapter 15: Handling Errors 796
Chapter 16: Overloading C Operators 796
Chapter 17: Writing Efficient C 797
Chapter 18: Developing Cross-Platform and Cross-Language Applications 798
Chapter 19: Becoming Adept at Testing 798
Chapter 20: Conquering Debugging 799
Chapters 21, 22, and 23: The Standard Template Library 799
Chapter 24: Exploring Distributed Objects 800
Chapter 25: Incorporating Techniques and Frameworks 801
Chapter 26: Applying Design Patterns 801
Appendix B: Annotated Bibliography 803
C 803
Beginning C 803
General C 804
I/O Streams 805
The C Standard Library 805
C Templates 806
xx
Contents
C 806
Integrating C and Other Languages 806
Algorithms and Data Structures 807
Open-Source Software 807
Software-Engineering Methodology 807
Programming Style 808
Computer Architecture 809
Efficiency 809
Testing 809
Debugging 809
Distributed Objects 810
CORBA 810
XML and SOAP 810
Design Patterns 811
Index 813