Beginning c++ programming richard grimes 1st edition

Customer Feedback

Preface

What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
- Downloading the example code
- Downloading the color images of this book
- Errata
- Piracy
- Questions

Starting with C++

What will you find in this chapter?
What is C++?
Installing Visual C++
- Setting up
- Downloading the installation files
- Installing Visual Studio
- Registering with Microsoft
Examining C++ projects
- Compilers
- Linking the code
- Source files
  - A simple example
  - Creating source files
  - Compiling the code
  - Passing parameters between the command-line and an executable
- The preprocessor and symbols
  - Defining constants
  - Using macros
  - Using symbols
  - Using pragmas
- Dependencies
  - Libraries
  - Pre-compiled headers
  - Project structure
  - Managing dependencies
  - Makefiles
Writing a simple project
- The project structure
- Creating the precompiled header
- Creating the main file
- Using input and output streams
- Using time functions
- Building the executable
- Testing the code
- Changing the project
Summary

Understanding Language Features

Writing C++
- Using white space
- Formatting code
- Writing statements
  - Working with expressions
  - Using the comma operator
- Using types and variables
- Using constants and literals
  - Defining constants
  - Using constant expressions
  - Using enumerations
  - Declaring pointers
- Using namespaces
- C++ scoping of variables
Using operators
- Exploring the built-in operators
  - Arithmetic operators
  - Increment and decrement operators
  - Bitwise operators
  - Boolean operators
  - Bitwise shift operators
  - Assignment operators
Controlling execution flow
- Using conditional statements
- Selecting
- Looping
  - Looping with iteration
  - Conditional loops
- Jumping
Using C++ language features
Summary

Exploring C++ Types

Exploring built-in types
- Integers
  - Specifying integer literals
    - Using bitset to show bit patterns
  - Determining integer byte order
- Floating point types
  - Specifying floating point literals
- Characters and strings
  - Character types
  - Using character macros
  - Specifying character literals
  - Specifying string literals
    - Unicode literals
    - Raw strings
    - String byte order
- Boolean
- void
- Initializers
- Default values
- Declarations without a type
- Storage classes
- Using type aliases
- Aggregating data in record types
  - Structures
    - Initializing
    - Structure fields
    - Using structure names
    - Determining alignment
  - Storing data in the same memory with unions
- Accessing runtime type information
- Determining type limits
Converting between types
- Type conversions
  - Promoting conversions
  - Narrowing conversions
  - Narrowing to bool
  - Converting signed types
- Casting
  - Casting away const-ness
  - Casting without runtime checks
  - Casting pointers without runtime checks
  - Casting with runtime checks
  - Casting with list initializer
  - Using C casts
Using C++ types
Summary

Working with Memory, Arrays, and Pointers

Using memory in C++
- Using C++ pointer syntax
- Using null pointers
- Types of memory
- Pointer arithmetic
Using arrays
- Function parameters
- Multidimensional arrays
- Passing multidimensional arrays to functions
- Using arrays of characters
  - Comparing strings
  - Preventing buffer overruns
Using pointers in C++
- Accessing out of bounds
- Pointers to deallocated memory
- Converting pointers
  - Constant pointers
  - Changing the type pointed to
Allocating memory in code
- Allocating individual objects
- Allocating arrays of objects
- Handling failed allocations
- Using other versions of the new operator
- Memory lifetime
- The Windows SDK and pointers
Memory and the C++ Standard Library
- Standard Library arrays
  - Using the stack-based array class
  - Using the dynamically allocated vector class
References
- Constant references
- Returning references
- Temporaries and references
- The rvalue references
- Ranged for and references
Using pointers in practice
- Creating the project
- Adding a task object to the list
- Deleting the task list
- Iterating the task list
- Inserting items
Summary

Using Functions

Defining C++ functions
- Declaring and defining functions
- Specifying linkage
- Inlining
- Determining the return type
- Naming the function
- Function parameters
- Specifying exceptions
- Function body
Using function parameters
- Passing Initializer lists
- Using default parameters
- Variable number of parameters
  - Initializer lists
  - Argument lists
Function features
- Call stack
- Specifying calling conventions
  - Using C linkage
  - Specifying how the stack Is maintained
- Using recursion
- Overloading functions
- Functions and scope
- Deleted functions
- Passing by value and passing by reference
Designing functions
- Pre- and post-conditions
- Using invariants
Function pointers
- Remember the parentheses!
- Declaring function pointers
- Using function pointers
Templated functions
- Defining templates
- Using template parameter values
- Specialized templates
- Variadic templates
Overloaded operators
- Function objects
- Introducing lambda expressions
Using functions in C++
Summary

Classes

Writing classes
- Reviewing structures
- Defining classes
- Defining class behavior
  - Using the this pointer
  - Using the scope resolution operator
  - Defining class state
- Creating objects
  - Construction of objects
  - Defining constructors
  - Delegating constructors
  - Copy constructor
  - Converting between types
  - Making friends
  - Marking constructors as explicit
  - Destructing objects
  - Assigning objects
  - Move semantics
- Declaring static members
  - Defining static members
  - Using static and global objects
  - Named constructors
- Nested classes
- Accessing const objects
Using objects with pointers
- Getting pointers to object members
- Operator overloading
- Defining function classes
- Defining conversion operators
- Managing resources
- Writing wrapper classes
- Using smart pointers
  - Managing exclusive ownership
  - Sharing ownership
  - Handling dangling pointers
Templates
Using classes
Summary

Introduction to Object-Orientated Programming

Inheritance and composition
- Inheriting from a class
- Overriding methods and hiding names
- Using pointers and references
- Access levels
  - Changing access level through inheritance
- Inheritance access levels
- Multiple inheritance
  - Object slicing
Introducing polymorphism
- Virtual methods
- Virtual method tables
- Multiple inheritance and virtual method tables
- Virtual methods, construction, and destruction
- Containers and virtual methods
- Friends and inheritance
- Override and final
- Virtual inheritance
- Abstract classes
- Obtaining type information
- Smart pointers and virtual methods
- Interfaces
- Class relationships
- Using mixin classes
Using polymorphism
Summary

Using the Standard Library Containers

Working with pairs and tuples
Containers
- Sequence containers
  - List
  - Forward list
  - Vector
  - Deque
- Associative containers
  - Maps and multimaps
  - Sets and multisets
  - Unordered containers
- Special purpose containers
- Using iterators
  - Input and output iterators
  - Stream iterators
  - Using iterators with the C Standard Library
Algorithms
- Iteration of items
- Getting information
- Comparing containers
- Changing Items
- Finding Items
- Sorting items
Using the numeric libraries
- Compile time arithmetic
- Complex numbers
Using the Standard Library
Summary

Using Strings

Using the string class as a container
- Getting information about a string
- Altering strings
- Searching strings
Internationalization
- Using facets
Strings and numbers
- Converting strings to numbers
- Converting numbers to strings
Using stream classes
- Outputting floating point numbers
- Outputting integers
- Outputting time and money
- Converting numbers to strings using streams
- Reading numbers from strings using streams
Using regular expressions
- Defining regular expressions
- Standard Library classes
  - Matching expressions
  - Using iterators
  - Replacing strings
Using strings
- Creating the project
- Processing header subitems
Summary

Diagnostics and Debugging

Preparing your code
- Invariants and conditions
- Conditional compilation
- Using pragmas
- Adding informational messages
- Compiler switches for debugging
- Pre-processor symbols
- Producing diagnostic messages
  - Trace messages with the C runtime
  - Tracing messages with Windows
- Using asserts
Application termination
Error values
- Obtaining message descriptions
- Using the Message Compiler
C++ exceptions
- Exception specifications
- C++ exception syntax
- Standard exception classes
- Catching exceptions by type
- Function try blocks
- System errors
- Nested exceptions
- Structured Exception Handling
- Compiler exception switches
- Mixing C++ and SEH exception handling
- Writing exception-safe classes
Summary