Home Page Icon
Home Page
Table of Contents for
cover
Close
cover
by Ray Lischner
Exploring C++ 11, Second Edition
Title Page
Contents at a Glance
Contents
About the Author
About the Technical Reviewers
Acknowledgments
Introduction
Exploration 1: Honing Your Tools
Ray’s Recommendations
Read the Documentation
Your First Program
Exploration 2: Reading C++ Code
Comments
Headers
Main Program
Variable Definitions
Statements
Output
Exploration 3: Integer Expressions
Exploration 4: Strings
Exploration 5: Simple Input
Exploration 6: Error Messages
Misspelling
Bogus Character
Unknown Operator
Unknown Name
Symbol Errors
Fun with Errors
Exploration 7: For Loops
Bounded Loops
Your Turn
Exploration 8: Formatted Output
The Problem
Field Width
Fill Character
std Prefix
Alignment
Exploring Formatting
Alternative Syntax
On Your Own
Exploration 9: Arrays and Vectors
Vectors for Arrays
Vectors
Iterators
Exploration 10: Algorithms and Iterators
Algorithms
Member Types
A Simpler Loop
Using Iterators and Algorithms
Exploration 11: Increment and Decrement
Increment
Decrement
Exploration 12: Conditions and Logic
I/O and bool
Boolean Type
Logic Operators
Old-Fashioned Syntax
Comparison Operators
Exploration 13: Compound Statements
Statements
Local Definitions and Scope
Definitions in for Loop Headers
Exploration 14: Introduction to File I/O
Reading Files
Writing Files
Exploration 15: The Map Data Structure
Using Maps
Pairs
Searching in Maps
Exploration 16: Type Synonyms
typedef Declarations
Common typedefs
Type Aliases
Exploration 17: Characters
Character Type
Character I/O
Newlines and Portability
Character Escapes
Exploration 18: Character Categories
Character Sets
Character Categories
Locales
Exploration 19: Case-Folding
Simple Cases
Harder Cases
Exploration 20: Writing Functions
Functions
Function Call
Declarations and Definitions
Counting Words—Again
The main( ) Function
Exploration 21: Function Arguments
Argument Passing
Pass-by-Reference
const References
const_iterator
Multiple Output Parameters
Exploration 22: Using Algorithms
Transforming Data
Predicates
Other Algorithms
Exploration 23: Unnamed Functions
Lambdas
Naming an Unnamed Function
Capturing Local Variables
const Capture
Return Type
Exploration 24: Overloading Function Names
Overloading
Exploration 25: Big and Little Numbers
The Long and Short of It
Integer Literals
Byte-Sized Integers
Type Casting
Make Up Your Own Literals
Integer Arithmetic
Overload Resolution
Exploration 26: Very Big and Very Little Numbers
Floating-Point Numbers
Floating-Point Literals
Floating-Point Traits
Floating-Point I/O
Exploration 27: Documentation
Doxygen
Structured Comments
Documentation Tags and Markdown
Using Doxygen
Exploration 28: Project 1: Body-Mass Index
Hints
Exploration 29: Custom Types
Defining a New Type
Member Functions
Constructors
Overloading Constructors
Exploration 30: Overloading Operators
Comparing Rational Numbers
Arithmetic Operators
Math Functions
Exploration 31: Custom I/O Operators
Input Operator
Output Operator
Error State
Exploration 32: Assignment and Initialization
Assignment Operator
Constructors
Putting It All Together
Exploration 33: Writing Classes
Anatomy of a Class
Member Functions
Constructor
Defaulted and Deleted Constructors
Exploration 34: More About Member Functions
Revisiting Project 1
Const Member Functions
Exploration 35: Access Levels
Public vs. Private
class vs. struct
Plain Old Data
Public or Private?
Exploration 36: Introduction to Object-Oriented Programming
Books and Magazines
Classification
Inheritance
Liskov’s Substitution Principle
Type Polymorphism
Exploration 37: Inheritance
Deriving a Class
Member Functions
Destructors
Access Level
Programming Style
Exploration 38: Virtual Functions
Type Polymorphism
Virtual Functions
References and Slices
Pure Virtual Functions
Virtual Destructors
Exploration 39: Classes and Types
Classes vs. typedefs
Value Types
Resource Acquisition Is Initialization
Exploration 40: Declarations and Definitions
Declaration vs. Definition
inline Functions
Variable Declarations and Definitions
Static Variables
Static Data Members
Declarators
Exploration 41: Using Multiple Source Files
Multiple Source Files
Declarations and Definitions
#include Files
extern Variables
inline Functions
One-Definition Rule
Exploration 42: Function Objects
The Function Call Operator
Function Objects
Exploration 43: Useful Algorithms
Searching
Comparing
Rearranging Data
Copying Data
Deleting Elements
Iterators
Exploration 44: Iterators
Kinds of Iterators
Working with Iterators
const_iterator vs. const iterator
Error Messages
Specialized Iterators
Exploration 45: Exceptions
Introducing Exceptions
Catching Exceptions
Throwing Exceptions
Program Stack
Standard Exceptions
I/O Exceptions
Custom Exceptions
Don’t Throw Exceptions
Exceptional Advice
Exploration 46: More Operators
Conditional Operator
Short-Circuit Operators
Comma Operator
Arithmetic Assignment Operators
Increment and Decrement
Exploration 47: Project 2: Fixed-Point Numbers
value_type
places
places10
fixed( )
fixed(value_type integer, value_type fraction)
fixed(double val)
to_string( )
round( )
integer( )
fraction( )
Exploration 48: Function Templates
Generic Functions
Using Function Templates
Writing Function Templates
Template Parameters
Template Arguments
Declarations and Definitions
Member Function Templates
Exploration 49: Class Templates
Parameterizing a Type
Parameterizing the rational Class
Using Class Templates
Overloaded Operators
Mixing Types
Exploration 50: Template Specialization
Instantiation and Specialization
Custom Comparators
Specializing Function Templates
Traits
Exploration 51: Partial Template Specialization
Degenerate Pairs
Partial Specialization
Partially Specializing Function Templates
Value Template Parameters
Exploration 52: Names and Namespaces
Namespaces
Nested Namespaces
Global Namespace
The std Namespace
Using Namespaces
Unnamed Namespaces
Name Lookup
Exploration 53: Containers
Properties of Containers
Member Types
What Can Go into a Container
Inserting and Erasing
Iterators and References
Sequence Containers
Associative Containers
Exploration 54: Locales and Facets
The Problem
Locales to the Rescue
Locales and I/O
Facets
Character Categories
Collation Order
Exploration 55: International Characters
Why Wide?
Using Wide Characters
Wide Strings
Wide Character I/O
Multi-Byte Character Sets
Unicode
Universal Character Names
Unicode Difficulties
Exploration 56: Text I/O
File Modes
String Streams
Text Conversion
Exploration 57: Project 3: Currency Type
Exploration 58: Pointers
A Programming Problem
The Solution
Addresses vs. Pointers
Dependency Graphs
Exploration 59: Dynamic Memory
Allocating Memory
Freeing Memory
Pointer to Nothing
Implementing Standard Containers
Adding Variables
Special Member Functions
Exploration 60: Moving Data with Rvalue References
Temporary Objects
Lvalues, Rvalues, and More
Implementing Move
Rvalue or Lvalue?
Special Member Functions
Exploration 61: Exception-Safety
Memory Leaks
Exceptions and Dynamic Memory
Automatically Deleting Pointers
Exceptions and Constructors
Exploration 62: Old-Fashioned Arrays
C-Style Arrays
Array Limitations
Dynamically Allocating an Array
The array Type
Multidimensional Arrays
C-Style Strings
Command-Line Arguments
Pointer Arithmetic
Exploration 63: Smart Pointers
Revisiting unique_ptr
Copyable Smart Pointers
Smart Arrays
Pimpls
Iterators
Exploration 64: Working with Bits
Integer As a Set of Bits
Bitmasks
Shifting Bits
Safe Shifting with Unsigned Types
Overflow
Introducing Bitfields
Portability
The bitset Class Template
Exploration 65: Enumerations
Scoped Enumerations
Unscoped Enumerations
Strings and Enumerations
Revisiting Projects
Exploration 66: Multiple Inheritance
Multiple Base Classes
Virtual Base Classes
Java-Like Interfaces
Interfaces vs. Templates
Mix-Ins
Exploration 67: Traits and Policies
Case Study: Iterators
Iterator Traits
Type Traits
Case Study: char_traits
Policy-Based Programming
Exploration 68: Names, Namespaces, and Templates
Common Rules
Name Lookup in Templates
Three Kinds of Name Lookup
Member Access Operators
Qualified Name Lookup
Unqualified Name Lookup
Argument-Dependent Lookup
Exploration 69: Overloaded Functions and Operators
Type Conversion
Review of Overloaded Functions
Overload Resolution
Default Arguments
Exploration 70: Metaprogramming
Use constexpr for Compile-Time Values
Variable-Length Template Argument Lists
Types as Values
Conditional Types
Checking Traits
Substitution Failure Is Not An Error (SFINAE)
Exploration 71: Project 4: Calculator
Index
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Next
Next Chapter
Title Page
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset