Log In
Or create an account ->
Imperial Library
Home
About
News
Upload
Forum
Help
Login/SignUp
Index
Practical C++ Programming
A Note Regarding Supplemental Files
Preface
Scope of This Handbook
How This Book Is Organized
How to Read This Book If You Already Know C
Font Conventions
How to Contact Us
Acknowledgments for the First Edition
Acknowledgments for the Second Edition
I. The Basics
1. What Is C++?
1.1. A Brief History of C++
1.2. C++ Organization
1.3. How to Learn C++
2. The Basics of Program Writing
2.1. Programs from Conception to Execution
2.2. Creating a Real Program
2.2.1. Creating a Program Using a Command-Line Compiler
2.2.1.1. Step 1: Create a place for your program
2.2.1.2. Step 2: Create the program
2.2.1.3. Step 3: Run the compiler
2.2.1.3.1. Unix CC Compiler (Generic Unix)
2.2.1.3.2. Free Software Foundation's g++ Compiler
2.2.1.3.3. Borland's Turbo C++
2.2.1.3.4. Microsoft Visual C++ .NET
2.2.1.4. Step 4: Execute the program
2.2.2. Creating a Program Using an Integrated Development Environment
2.2.2.1. Borland C++
2.2.2.2. Microsoft Visual C++
2.3. Getting Help in Unix
2.4. Getting Help in an IDE
2.5. Programming Exercises
3. Style
3.1. Comments
3.2. C++ Code
3.3. Naming Style
3.4. Coding Religion
3.5. Indentation and Code Format
3.6. Clarity
3.7. Simplicity
3.8. Consistency and Organization
3.9. Further Reading
3.10. Summary
4. Basic Declarations and Expressions
4.1. Basic Program Structure
4.2. Simple Expressions
4.3. The std::cout Output Object
4.4. Variables and Storage
4.5. Variable Declarations
4.6. Integers
4.7. Assignment Statements
4.8. Floating-Point Numbers
4.9. Floating-Point Divide Versus Integer Divide
4.10. Characters
4.11. Wide Characters
4.12. Boolean Type
4.13. Programming Exercises
4.14. Answers to Chapter Questions
5. Arrays, Qualifiers, and Reading Numbers
5.1. Arrays
5.2. Strings
5.2.1. Wide Strings
5.3. Reading Data
5.4. Initializing Variables
5.4.1. Bounds Errors
5.5. Multidimensional Arrays
5.6. C-Style Strings
5.6.1. Safety and C Strings
5.6.2. Reading C-Style Strings
5.6.3. Converting Between C-Style and C++ Strings
5.6.4. The Differences Between C++ and C-Style Strings
5.7. Types of Integers
5.7.1. Summary of Integer Types
5.8. Types of Floats
5.9. Constant and Reference Declarations
5.10. Qualifiers
5.10.1. Special
5.10.2. Constant
5.10.3. Storage Class
5.10.4. Size
5.10.5. Sign
5.10.6. Type
5.11. Hexadecimal and Octal Constants
5.12. Operators for Performing Shortcuts
5.13. Side Effects
5.14. Programming Exercises
5.15. Answers to Chapter Questions
6. Decision and Control Statements
6.1. if Statement
6.2. else Statement
6.3. How Not to Use std::strcmp
6.4. Looping Statements
6.5. while Statement
6.6. break Statement
6.7. continue Statement
6.8. The Assignment Anywhere Side Effect
6.9. Programming Exercises
6.10. Answers to Chapter Questions
7. The Programming Process
7.1. Setting Up Your Work Area
7.2. The Specification
7.3. Code Design
7.4. The Prototype
7.5. The Makefile
7.6. Testing
7.7. Debugging
7.8. Maintenance
7.9. Revisions
7.10. Electronic Archaeology
7.11. Mark Up the Program
7.12. Use the Debugger
7.13. Use the Text Editor as a Browser
7.14. Add Comments
7.15. Programming Exercises
II. Simple Programming
8. More Control Statements
8.1. for Statement
8.2. switch Statement
8.3. switch, break, and continue
8.4. Programming Exercises
8.5. Answers to Chapter Questions
9. Variable Scope and Functions
9.1. Scope and Storage Class
9.1.1. The for Scope
9.2. Namespaces
9.2.1. Namespace std
9.2.2. Global Namespace
9.2.3. File-Specific Namespace
9.2.4. Nested Namespaces
9.2.5. The using Statement
9.2.5.1. The problem with the using statement
9.3. Functions
9.3.1. Returning void
9.3.2. Namespaces and Functions
9.3.3. const Parameters and Return Values
9.3.4. Reference Parameters and Return Values
9.3.5. Dangling References
9.3.6. Array Parameters
9.3.7. Function Overloading
9.3.8. Default Arguments
9.3.9. Unused Parameters
9.3.10. Inline Functions
9.4. Summary of Parameter Types
9.5. Recursion
9.6. Structured Programming Basics
9.7. Real-World Programming
9.8. Programming Exercises
9.9. Answers to Chapter Questions
10. The C++ Preprocessor
10.1. #define Statement
10.1.1. #define Versus const
10.2. Conditional Compilation
10.3. #include Files
10.4. Parameterized Macros
10.4.1. The # Operator
10.4.2. Parameterized Macros Versus Inline Functions
10.5. Advanced Features
10.6. Summary
10.7. Programming Exercises
10.8. Answers to Chapter Questions
11. Bit Operations
11.1. Bit Operators
11.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 Details
11.7. Setting, Clearing, and Testing Bits
11.8. Bitmapped Graphics
11.9. Programming Exercises
11.10. Answers to Chapter Questions
III. Advanced Types and Classes
12. Advanced Types
12.1. Structures
12.2. Unions
12.3. typedef
12.4. enum Type
12.5. Bit Members or Packed Structures
12.6. Arrays of Structures
12.7. Programming Exercises
12.8. Answers to Chapter Questions
13. Simple Classes
13.1. Stacks
13.1.1. Designing a Stack
13.2. Improved Stack
13.3. Using a Class
13.4. Introduction to Constructors and Destructors
13.4.1. Destructors
13.4.2. Parameterized Constructors
13.4.3. Parameterized Destructors
13.4.4. Copy Constructor
13.5. Automatically Generated Member Functions
13.5.1. Automatically Generated and Used Functions
13.5.2. Explicit Constructors
13.6. Shortcuts
13.7. Style
13.8. Structures Versus Classes
13.9. Programming Exercises
14. More on Classes
14.1. Friends
14.1.1. Friend Functions
14.1.2. Friend Classes
14.2. Constant Functions
14.3. Constant Members
14.4. Static Member Variables
14.5. Static Member Functions
14.6. The Meaning of static
14.7. Programming Exercises
15. Simple Pointers
15.1. const Pointers
15.2. Pointers and Printing
15.3. Pointers and Arrays
15.3.1. Splitting a C-Style String
15.4. The reinterpret_cast
15.5. Pointers and Structures
15.6. Command-Line Arguments
15.7. Programming Exercises
15.8. Answers to Chapter Questions
IV. Advanced Programming Concepts
16. File Input/Output
16.1. C++ File I/O
16.1.1. Reading C-Style Strings
16.1.2. Output Files
16.2. Conversion Routines
16.3. Binary and ASCII Files
16.4. The End-of-Line Puzzle
16.5. Binary I/O
16.6. Buffering Problems
16.7. Unbuffered I/O
16.8. Designing File Formats
16.9. C-Style I/O Routines
16.10. C-Style Conversion Routines
16.10.1. The std::printf Family of Output Functions
16.10.2. The std::scanf Family of Input Functions
16.11. C-Style Binary I/O
16.12. C- Versus C++- Style I/O
16.12.1. Simplicity
16.12.2. Reliability
16.12.3. Speed
16.12.4. Which Should You Use?
16.13. Programming Exercises
16.14. Answers to Chapter Questions
17. Debugging and Optimization
17.1. Code Reviews
17.1.1. Planning the Review
17.1.2. The Review Meeting
17.1.3. Why People Don't Do Code Reviews
17.1.4. Metrics
17.2. Serial Debugging
17.2.1. Divide and Conquer
17.2.2. The Confessional Method of Debugging
17.2.3. Debug-Only Code
17.2.4. Debug Command-Line Switch
17.3. Going Through the Output
17.4. Interactive Debuggers
17.4.1. Basic Debugging Commands
17.4.2. Debugging a Simple Program
17.5. Debugging a Binary Search
17.5.1. The First Bug, a Segmentation Fault
17.5.2. The Unintended Infinite Loop
17.6. Interactive Debugging Tips and Tricks
17.7. Runtime Errors
17.8. Optimization
17.8.1. Profiling
17.8.2. Analyzing and Optimizing code
17.8.3. Register Declarations
17.8.3.1. Loop ordering
17.8.3.2. The power of powers of 2
17.8.3.3. Making use of pointers
17.8.4. Using the System Library
17.9. How to Optimize
17.10. Case Study: Inline Functions Versus Normal Functions
17.11. Case Study: Optimizing a Color-Rendering Algorithm
17.12. Programming Exercises
17.13. Answers to Chapter Questions
18. Operator Overloading
18.1. Creating a Simple Fixed-Point Class
18.1.1. Fixed Point Basics
18.1.2. Creating the fixed_pt Class
18.2. Operator Functions
18.2.1. Binary Arithmetic Operators
18.2.2. Relational Operators
18.2.3. Unary Operators
18.2.4. Shortcut Operators
18.2.5. Increment and Decrement Operators
18.2.6. Logical Operators
18.2.7. I/O Operators
18.2.8. Index Operator "[ ]"
18.2.9. new and delete
18.2.10. Exotic Operators
18.3. Operator Member Functions
18.3.1. Casting
18.4. Warts
18.5. Full Definition of the Fixed-Point Class
18.6. Programming Exercises
18.7. Answers to Chapter Questions
19. Floating Point
19.1. Floating-Point Format
19.2. Floating Addition/Subtraction
19.3. Multiplication and Division
19.4. Overflow and Underflow
19.5. Roundoff Error
19.6. Accuracy
19.7. Minimizing Roundoff Error
19.8. Determining Accuracy
19.9. Precision and Speed
19.10. Power Series
19.11. Programming Exercises
20. Advanced Pointers
20.1. Pointers, Structures, and Classes
20.2. delete Operator
20.3. Linked Lists
20.4. Ordered Linked Lists
20.5. Doubly Linked Lists
20.6. Trees
20.7. Printing a Tree
20.8. The Rest of the Program
20.9. Data Structures for a Chess Program
20.10. Programming Exercises
20.11. Answers to Chapter Questions
21. Advanced Classes
21.1. Derived Classes
21.2. Virtual Functions
21.3. Virtual Classes
21.4. Function Hiding in Derived Classes
21.5. Constructors and Destructors in Derived Classes
21.6. The dynamic_cast Operator
21.7. Summary
21.8. Programming Exercises
21.9. Answers to Chapter Questions
V. Other Language Features
22. Exceptions
22.1. Adding Exceptions to the Stack Class
22.1.1. Creating an Exception
22.1.2. Using a Try Block for Normal Execution
22.1.3. Throwing an Exception
22.1.4. Exceptions and Destructors
22.2. Exceptions Versus assert
22.3. Programming Exercises
23. Modular Programming
23.1. Modules
23.2. Public and Private
23.3. The extern Storage Class
23.4. Headers
23.5. The Body of the Module
23.6. A Program to Use Infinite Arrays
23.7. The Makefile for Multiple Files
23.8. Using the Infinite Array
23.9. Dividing a Task into Modules
23.10. Module Design Guidelines
23.11. Programming Exercises
24. Templates
24.1. What Is a Template?
24.2. Templates: The Hard Way
24.3. Templates: The C++ Way
24.4. Function Specialization
24.5. Class Templates
24.6. Class Specialization
24.7. Implementation Details
24.7.1. Real-World Templates
24.7.2. When to Generate Code
24.7.3. Writing Portable Templates
24.8. Advanced Features
24.8.1. Default Parameters
24.8.2. Partial Specialization
24.9. Summary
24.10. Programming Exercises
25. Standard Template Library
25.1. STL Basics
25.1.1. Containers
25.1.2. Iterators
25.1.3. Algorithms
25.2. Class List—A Set of Students
25.2.1. Iterating Through a Set
25.2.2. Using std::foreach to Write Out the Set
25.2.3. Multisets
25.3. Creating a Waiting List with the STL List
25.4. Storing Grades in a STL Map
25.5. Putting It All Together
25.6. Practical Considerations When Using the STL
25.6.1. Getting the Types Right
25.6.2. Error Messages
25.7. Getting More Information
25.8. Exercises
26. Program Design
26.1. Design Goals
26.2. Design Factors
26.3. Design Principles
26.4. Coding
26.4.1. Procedure Design
26.4.1.1. Procedure interface
26.4.1.2. Global variables
26.4.1.3. Information hiding
26.4.1.4. Coding details
26.4.2. Modules and Structured Programming
26.4.2.1. Interconnections
26.4.3. Real-Life Module Organization
26.4.4. Module Summary
26.5. Objects
26.5.1. Interfaces and C++ Classes
26.6. Real-World Design Techniques
26.6.1. The Linked List Problem
26.6.2. Callbacks
26.6.3. Decoupling the Interface and Implementation
26.7. Conclusion
27. Putting It All Together
27.1. Requirements
27.2. Code Design
27.2.1. Token Module
27.2.2. Character-Type Module
27.2.3. Statistics Class
27.3. Coding
27.4. Functional Description
27.4.1. char_type Class
27.4.2. input_file Class
27.4.3. token Class
27.4.4. stat Class
27.4.5. line_counter Class
27.4.6. brace_counter Class
27.4.7. paren_counter Class
27.4.8. comment_counter Class
27.4.9. do_file Procedure
27.5. Testing
27.6. Revisions
27.7. A Final Warning
27.8. Program Files
27.9. Programming Exercises
28. From C to C++
28.1. K&R-Style Functions
28.1.1. Prototypes
28.2. struct
28.3. malloc and free
28.3.1. The C malloc function
28.3.2. The C free function
28.4. Turning Structures into Classes
28.5. setjmp and longjmp
28.6. Mixing C and C++ Code
28.7. Summary
28.8. Programming Exercise
29. C++'s Dustier Corners
29.1. do/while
29.2. goto
29.3. The ?: Construct
29.4. The Comma Operator
29.5. Overloading the ( ) Operator
29.6. Pointers to Members
29.7. The asm Statement
29.8. The mutable Qualifier
29.9. Run Time Type Identification
29.10. Trigraphs
29.11. Answers to Chapter Questions
30. Programming Adages
30.1. General
30.2. Design
30.3. Declarations
30.4. switch Statement
30.5. Preprocessor
30.6. Style
30.7. Compiling
30.8. The Ten Commandments for C++ Programmers
30.9. Final Note
30.10. Answers to Chapter Questions
VI. Appendixes
A. ASCII Table
B. Ranges
C. Operator Precedence Rules
C.1. Standard Rules
C.2. Practical Subset of the Operator Precedence Rules
D. Computing Sine Using a Power Series
E. Resources
E.1. Compilers
E.2. Standard Template Library
E.3. Standards
E.4. Programming Tools
Index
About the Author
Colophon
← Prev
Back
Next →
← Prev
Back
Next →