book

Practical C++ Programming, 2nd Edition

by Steve Oualline

December 2002

Beginner to intermediate

576 pages

14h 6m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Scope of This HandbookHow This Book Is OrganizedHow to Read This Book If You Already Know CFont ConventionsHow to Contact UsAcknowledgments for the First EditionAcknowledgments for the Second Edition
1.1. A Brief History of C++1.2. C++ Organization1.3. How to Learn C++
2.1. Programs from Conception to Execution2.2. Creating a Real Program2.2.1. Creating a Program Using a Command-Line Compiler2.2.1.1. Step 1: Create a place for your program2.2.1.2. Step 2: Create the program2.2.1.3. Step 3: Run the compiler2.2.1.3.1. Unix CC Compiler (Generic Unix)2.2.1.3.2. Free Software Foundation’s g++ Compiler2.2.1.3.3. Borland’s Turbo C++2.2.1.3.4. Microsoft Visual C++ .NET2.2.1.4. Step 4: Execute the program2.2.2. Creating a Program Using an Integrated Development Environment2.2.2.1. Borland C++2.2.2.2. Microsoft Visual C++2.3. Getting Help in Unix2.4. Getting Help in an IDE2.5. Programming Exercises
3.1. Comments3.2. C++ Code3.3. Naming Style3.4. Coding Religion3.5. Indentation and Code Format3.6. Clarity3.7. Simplicity3.8. Consistency and Organization3.9. Further Reading3.10. Summary
4.1. Basic Program Structure4.2. Simple Expressions4.3. The std::cout Output Object4.4. Variables and Storage4.5. Variable Declarations4.6. Integers4.7. Assignment Statements4.8. Floating-Point Numbers4.9. Floating-Point Divide Versus Integer Divide4.10. Characters4.11. Wide Characters4.12. Boolean Type4.13. Programming Exercises4.14. Answers to Chapter Questions
5.1. Arrays5.2. Strings5.2.1. Wide Strings5.3. Reading Data5.4. Initializing Variables5.4.1. Bounds Errors5.5. Multidimensional Arrays5.6. C-Style Strings5.6.1. Safety and C Strings5.6.2. Reading C-Style Strings5.6.3. Converting Between C-Style and C++ Strings5.6.4. The Differences Between C++ and C-Style Strings5.7. Types of Integers5.7.1. Summary of Integer Types5.8. Types of Floats5.9. Constant and Reference Declarations5.10. Qualifiers5.10.1. Special5.10.2. Constant5.10.3. Storage Class5.10.4. Size5.10.5. Sign5.10.6. Type5.11. Hexadecimal and Octal Constants5.12. Operators for Performing Shortcuts5.13. Side Effects5.14. Programming Exercises5.15. Answers to Chapter Questions
6.1. if Statement6.2. else Statement6.3. How Not to Use std::strcmp6.4. Looping Statements6.5. while Statement6.6. break Statement6.7. continue Statement6.8. The Assignment Anywhere Side Effect6.9. Programming Exercises6.10. Answers to Chapter Questions

7.1. Setting Up Your Work Area7.2. The Specification7.3. Code Design7.4. The Prototype7.5. The Makefile7.6. Testing7.7. Debugging7.8. Maintenance7.9. Revisions7.10. Electronic Archaeology7.11. Mark Up the Program7.12. Use the Debugger7.13. Use the Text Editor as a Browser7.14. Add Comments7.15. Programming Exercises
8.1. for Statement8.2. switch Statement8.3. switch, break, and continue8.4. Programming Exercises8.5. Answers to Chapter Questions
9.1. Scope and Storage Class9.1.1. The for Scope9.2. Namespaces9.2.1. Namespace std9.2.2. Global Namespace9.2.3. File-Specific Namespace9.2.4. Nested Namespaces9.2.5. The using Statement9.2.5.1. The problem with the using statement9.3. Functions9.3.1. Returning void9.3.2. Namespaces and Functions9.3.3. const Parameters and Return Values9.3.4. Reference Parameters and Return Values9.3.5. Dangling References9.3.6. Array Parameters9.3.7. Function Overloading9.3.8. Default Arguments9.3.9. Unused Parameters9.3.10. Inline Functions9.4. Summary of Parameter Types9.5. Recursion9.6. Structured Programming Basics9.7. Real-World Programming9.8. Programming Exercises9.9. Answers to Chapter Questions
10.1. #define Statement10.1.1. #define Versus const10.2. Conditional Compilation10.3. #include Files10.4. Parameterized Macros10.4.1. The # Operator10.4.2. Parameterized Macros Versus Inline Functions10.5. Advanced Features10.6. Summary10.7. Programming Exercises10.8. Answers to Chapter Questions
11.1. Bit Operators11.2. The AND Operator (&)11.3. Bitwise OR (|)11.4. The Bitwise Exclusive OR (^)11.5. The Ones Complement Operator (NOT) (~)11.6. The Left and Right Shift Operators (<<, >>)11.6.1. Right Shift Details11.7. Setting, Clearing, and Testing Bits11.8. Bitmapped Graphics11.9. Programming Exercises11.10. Answers to Chapter Questions
12.1. Structures12.2. Unions12.3. typedef12.4. enum Type12.5. Bit Members or Packed Structures12.6. Arrays of Structures12.7. Programming Exercises12.8. Answers to Chapter Questions
13.1. Stacks13.1.1. Designing a Stack13.2. Improved Stack13.3. Using a Class13.4. Introduction to Constructors and Destructors13.4.1. Destructors13.4.2. Parameterized Constructors13.4.3. Parameterized Destructors13.4.4. Copy Constructor13.5. Automatically Generated Member Functions13.5.1. Automatically Generated and Used Functions13.5.2. Explicit Constructors13.6. Shortcuts13.7. Style13.8. Structures Versus Classes13.9. Programming Exercises
14.1. Friends14.1.1. Friend Functions14.1.2. Friend Classes14.2. Constant Functions14.3. Constant Members14.4. Static Member Variables14.5. Static Member Functions14.6. The Meaning of static14.7. Programming Exercises
15.1. const Pointers15.2. Pointers and Printing15.3. Pointers and Arrays15.3.1. Splitting a C-Style String15.4. The reinterpret_cast15.5. Pointers and Structures15.6. Command-Line Arguments15.7. Programming Exercises15.8. Answers to Chapter Questions
16.1. C++ File I/O16.1.1. Reading C-Style Strings16.1.2. Output Files16.2. Conversion Routines16.3. Binary and ASCII Files16.4. The End-of-Line Puzzle16.5. Binary I/O16.6. Buffering Problems16.7. Unbuffered I/O16.8. Designing File Formats16.9. C-Style I/O Routines16.10. C-Style Conversion Routines16.10.1. The std::printf Family of Output Functions16.10.2. The std::scanf Family of Input Functions16.11. C-Style Binary I/O16.12. C- Versus C++- Style I/O16.12.1. Simplicity16.12.2. Reliability16.12.3. Speed16.12.4. Which Should You Use?16.13. Programming Exercises16.14. Answers to Chapter Questions
17.1. Code Reviews17.1.1. Planning the Review17.1.2. The Review Meeting17.1.3. Why People Don’t Do Code Reviews17.1.4. Metrics17.2. Serial Debugging17.2.1. Divide and Conquer17.2.2. The Confessional Method of Debugging17.2.3. Debug-Only Code17.2.4. Debug Command-Line Switch17.3. Going Through the Output17.4. Interactive Debuggers17.4.1. Basic Debugging Commands17.4.2. Debugging a Simple Program17.5. Debugging a Binary Search17.5.1. The First Bug, a Segmentation Fault17.5.2. The Unintended Infinite Loop17.6. Interactive Debugging Tips and Tricks17.7. Runtime Errors17.8. Optimization17.8.1. Profiling17.8.2. Analyzing and Optimizing code17.8.3. Register Declarations17.8.3.1. Loop ordering17.8.3.2. The power of powers of 217.8.3.3. Making use of pointers17.8.4. Using the System Library17.9. How to Optimize17.10. Case Study: Inline Functions Versus Normal Functions17.11. Case Study: Optimizing a Color-Rendering Algorithm17.12. Programming Exercises17.13. Answers to Chapter Questions
18.1. Creating a Simple Fixed-Point Class18.1.1. Fixed Point Basics18.1.2. Creating the fixed_pt Class18.2. Operator Functions18.2.1. Binary Arithmetic Operators18.2.2. Relational Operators18.2.3. Unary Operators18.2.4. Shortcut Operators18.2.5. Increment and Decrement Operators18.2.6. Logical Operators18.2.7. I/O Operators18.2.8. Index Operator “[ ]”18.2.9. new and delete18.2.10. Exotic Operators18.3. Operator Member Functions18.3.1. Casting18.4. Warts18.5. Full Definition of the Fixed-Point Class18.6. Programming Exercises18.7. Answers to Chapter Questions
19.1. Floating-Point Format19.2. Floating Addition/Subtraction19.3. Multiplication and Division19.4. Overflow and Underflow19.5. Roundoff Error19.6. Accuracy19.7. Minimizing Roundoff Error19.8. Determining Accuracy19.9. Precision and Speed19.10. Power Series19.11. Programming Exercises
20.1. Pointers, Structures, and Classes20.2. delete Operator20.3. Linked Lists20.4. Ordered Linked Lists20.5. Doubly Linked Lists20.6. Trees20.7. Printing a Tree20.8. The Rest of the Program20.9. Data Structures for a Chess Program20.10. Programming Exercises20.11. Answers to Chapter Questions
21.1. Derived Classes21.2. Virtual Functions21.3. Virtual Classes21.4. Function Hiding in Derived Classes21.5. Constructors and Destructors in Derived Classes21.6. The dynamic_cast Operator21.7. Summary21.8. Programming Exercises21.9. Answers to Chapter Questions
22.1. Adding Exceptions to the Stack Class22.1.1. Creating an Exception22.1.2. Using a Try Block for Normal Execution22.1.3. Throwing an Exception22.1.4. Exceptions and Destructors22.2. Exceptions Versus assert22.3. Programming Exercises
23.1. Modules23.2. Public and Private23.3. The extern Storage Class23.4. Headers23.5. The Body of the Module23.6. A Program to Use Infinite Arrays23.7. The Makefile for Multiple Files23.8. Using the Infinite Array23.9. Dividing a Task into Modules23.10. Module Design Guidelines23.11. Programming Exercises
24.1. What Is a Template?24.2. Templates: The Hard Way24.3. Templates: The C++ Way24.4. Function Specialization24.5. Class Templates24.6. Class Specialization24.7. Implementation Details24.7.1. Real-World Templates24.7.2. When to Generate Code24.7.3. Writing Portable Templates24.8. Advanced Features24.8.1. Default Parameters24.8.2. Partial Specialization24.9. Summary24.10. Programming Exercises
25.1. STL Basics25.1.1. Containers25.1.2. Iterators25.1.3. Algorithms25.2. Class List—A Set of Students25.2.1. Iterating Through a Set25.2.2. Using std::foreach to Write Out the Set25.2.3. Multisets25.3. Creating a Waiting List with the STL List25.4. Storing Grades in a STL Map25.5. Putting It All Together25.6. Practical Considerations When Using the STL25.6.1. Getting the Types Right25.6.2. Error Messages25.7. Getting More Information25.8. Exercises
26.1. Design Goals26.2. Design Factors26.3. Design Principles26.4. Coding26.4.1. Procedure Design26.4.1.1. Procedure interface26.4.1.2. Global variables26.4.1.3. Information hiding26.4.1.4. Coding details26.4.2. Modules and Structured Programming26.4.2.1. Interconnections26.4.3. Real-Life Module Organization26.4.4. Module Summary26.5. Objects26.5.1. Interfaces and C++ Classes26.6. Real-World Design Techniques26.6.1. The Linked List Problem26.6.2. Callbacks26.6.3. Decoupling the Interface and Implementation26.7. Conclusion
27.1. Requirements27.2. Code Design27.2.1. Token Module27.2.2. Character-Type Module27.2.3. Statistics Class27.3. Coding27.4. Functional Description27.4.1. char_type Class27.4.2. input_file Class27.4.3. token Class27.4.4. stat Class27.4.5. line_counter Class27.4.6. brace_counter Class27.4.7. paren_counter Class27.4.8. comment_counter Class27.4.9. do_file Procedure27.5. Testing27.6. Revisions27.7. A Final Warning27.8. Program Files27.9. Programming Exercises
28.1. K&R-Style Functions28.1.1. Prototypes28.2. struct28.3. malloc and free28.3.1. The C malloc function28.3.2. The C free function28.4. Turning Structures into Classes28.5. setjmp and longjmp28.6. Mixing C and C++ Code28.7. Summary28.8. Programming Exercise
29.1. do/while29.2. goto29.3. The ?: Construct29.4. The Comma Operator29.5. Overloading the ( ) Operator29.6. Pointers to Members29.7. The asm Statement29.8. The mutable Qualifier29.9. Run Time Type Identification29.10. Trigraphs29.11. Answers to Chapter Questions
30.1. General30.2. Design30.3. Declarations30.4. switch Statement30.5. Preprocessor30.6. Style30.7. Compiling30.8. The Ten Commandments for C++ Programmers30.9. Final Note30.10. Answers to Chapter Questions
C.1. Standard RulesC.2. Practical Subset of the Operator Precedence Rules
E.1. CompilersE.2. Standard Template LibraryE.3. StandardsE.4. Programming Tools