Beginning C++ programming this is the start of your journey into the most powerful language available to the programming public
You will finish the book not only being able to write your own code, but more importantly, you will be able to read other projects. It is only by being able to read others' code that you will progress from a beginner to an advanced programmer. This book is the first step in that progression. Th...
| Main Author: | |
|---|---|
| Format: | eBook |
| Language: | English |
| Published: |
Birmingham, UK
Packt Publishing
2017
|
| Subjects: | |
| Online Access: | |
| Collection: | O'Reilly - Collection details see MPG.ReNa |
Table of Contents:
- 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
- Chapter 4: 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
- 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
- Chapter 7: 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
- Chapter 8: 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
- 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
- Chapter 5: 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
- Chapter 6: 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
- Cover
- Credits
- About the Author
- About the Reviewer
- www.PacktPub.com
- Customer Feedback
- Table of Contents
- Preface
- Chapter 1: 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
- Chapter 2: 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
- Chapter 3: Exploring C++ Types
- Exploring built-in types
- Getting information
- Comparing containers
- Changing Items
- Finding Items
- Sorting items
- Using the numeric libraries
- Compile time arithmetic
- Complex numbers
- Using the Standard Library
- Summary
- Chapter 9: 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
- Chapter 10: 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
- Index