- Copyright
- About the Author
- Acknowledgments
- Publisher's Acknowledgments
- Introduction
- What's in This Book
- What's on the CD
- What Is C++?
- Conventions Used in This Book
- How This Book Is Organized
- And There's More
- Part I: Introduction to C++ Programming
- Part II: Becoming a Functional C++ Programmer
- Part III: Introduction to Classes
- Part IV: Inheritance
- Part V: Optional Features
- Part VI: The Part of Tens
- Icons Used in This Book
- Where to Go from Here
- I. Introduction to C++ Programming
- 1. Writing Your First C++ Program
- 2. Declaring Variables Constantly
- 3. Performing Mathematical Operations
- 4. Performing Logical Operations
- 5. Controlling Program Flow
- II. Becoming a Functional C++ Programmer
- 6. Creating Functions
- 7. Storing Sequences in Arrays
- 8. Taking a First Look at C++ Pointers
- 9. Taking a Second Look at C++ Pointers
- 9.1. Defining Operations on Pointer Variables
- 9.1.1. Reexamining arrays in light of pointer variables
- 9.1.2. Applying operators to the address of an array
- 9.1.3. Expanding pointer operations to a string
- 9.1.4. Justifying pointer-based string manipulation
- 9.1.5. Applying operators to pointer types other than char
- 9.1.6. Contrasting a pointer with an array
- 9.2. When Is a Pointer Not?
- 9.3. Declaring and Using Arrays of Pointers
- 9.1. Defining Operations on Pointer Variables
- 10. The C++ Preprocessor
- III. Introduction to Classes
- 11. Examining Object-Oriented Programming
- 12. Adding Class to C++
- 12.1. Introducing the Class
- 12.2. The Format of a Class
- 12.3. Accessing the Members of a Class
- 12.4. Activating Our Objects
- 12.5. Adding a Member Function
- 12.6. Calling a Member Function
- 12.7. Scope Resolution (And I Don't Mean How Well Your Microscope Works)
- 12.8. Defining a Member Function in the Class
- 12.9. Keeping a Member Function After Class
- 12.10. Overloading Member Functions
- 13. Point and Stare at Objects
- 13.1. Declaring Arrays of Objects
- 13.2. Declaring Pointers to Objects
- 13.3. Passing Objects to Functions
- 13.4. Why Bother with Pointers or References?
- 13.5. Returning to the Heap
- 13.6. Comparing Pointers to References
- 13.7. Linking Up with Linked Lists
- 13.8. A Ray of Hope: A List of Containers Linked to the C++ Library
- 14. Protecting Members: Do Not Disturb
- 15. Why Do You Build Me Up, Just to Tear Me Down Baby?
- 16. Making Constructive Arguments
- 16.1. Outfitting Constructors with Arguments
- 16.2. Placing Too Many Demands on the Carpenter: Overloading the Constructor
- 16.3. Defaulting Default Constructors
- 16.4. Constructing Class Members
- 16.5. Reconstructing the Order of Construction
- 16.5.1. Local objects construct in order
- 16.5.2. Static objects construct only once
- 16.5.3. All global objects construct before main()
- 16.5.4. Global objects construct in no particular order
- 16.5.5. Members construct in the order in which they are declared
- 16.5.6. Destructors destruct in the reverse order of the constructors
- 16.6. Constructors as a Form of Conversion
- 17. Copying the Copy Copy Copy Constructor
- 18. Static Members: Can Fabric Softener Help?
- IV. Inheritance
- V. Optional Features
- 22. A New Assignment Operator, Should You Decide to Accept It
- 23. Using Stream I/O
- 24. Handling Errors — Exceptions
- 25. Inheriting Multiple Inheritance
- 26. Tempting C++ Templates
- 27. Standardizing on the Standard Template Library
- VI. The Part of Tens
- 28. Ten Ways to Avoid Adding Bugs to Your Program
- 28.1. Enable All Warnings and Error Messages
- 28.2. Adopt a Clear and Consistent Coding Style
- 28.3. Limit the Visibility
- 28.4. Comment Your Code While You Write It
- 28.5. Single-Step Every Path at Least Once
- 28.6. Avoid Overloading Operators
- 28.7. Manage the Heap Systematically
- 28.8. Use Exceptions to Handle Errors
- 28.9. Declare Destructors Virtual
- 28.10. Avoid Multiple Inheritance
- 29. Ten Major Recent Additions to C++
- 29.1. Use Smart Pointers
- 29.2. Initialize Variables with a Variable-Length List
- 29.3. Initialize Data Members Inline
- 29.4. Instantiate an Extern Template
- 29.5. Implement Thread Local Storage
- 29.6. Use Rvalue References
- 29.7. Implement Concepts
- 29.8. Define Lamda Expressions
- 29.9. Define Variadic Templates
- 29.10. Use typeid()
- 28. Ten Ways to Avoid Adding Bugs to Your Program
- A. About the CD
What For Dummies book would be complete without a Part of Tens? In Chapter 28, I cover ten ways to avoid adding bugs to your C++ program. (Most of these suggestions work for C programs too, at no extra charge.)
Chapter 29 lists ten major additions to the language in recent years. Each of these extensions seems to be dragging the language in a different direction. Once you feel comfortable with the topics covered in this book, you may want to use this section as a guide in your further studies of the language.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.