Advanced C++
Master the technique of confidently writing robust C++ code
1st Edition
Published on 31. October 2019
762 pages
978-1-83882-936-0 (ISBN)
Description
Become an expert at C++ by learning all the key C++ concepts and working through interesting exercisesKey Features - Explore C++ concepts through descriptive graphics and interactive exercises
- Learn how to keep your development bug-free with testing and debugging
- Discover various techniques to optimize your code
Book DescriptionC++ is one of the most widely used programming languages and is applied in a variety of domains, right from gaming to graphical user interface (GUI) programming and even operating systems. If you're looking to expand your career opportunities, mastering the advanced features of C++ is key. The book begins with advanced C++ concepts by helping you decipher the sophisticated C++ type system and understand how various stages of compilation convert source code to object code. You'll then learn how to recognize the tools that need to be used in order to control the flow of execution, capture data, and pass data around. By creating small models, you'll even discover how to use advanced lambdas and captures and express common API design patterns in C++. As you cover later chapters, you'll explore ways to optimize your code by learning about memory alignment, cache access, and the time a program takes to run. The concluding chapter will help you to maximize performance by understanding modern CPU branch prediction and how to make your code cache-friendly. By the end of this book, you'll have developed programming skills that will set you apart from other C++ programmers.What you will learn - Delve into the anatomy and workflow of C++
- Study the pros and cons of different approaches to coding in C++
- Test, run, and debug your programs
- Link object files as a dynamic library
- Use templates, SFINAE, constexpr if expressions and variadic templates
- Apply best practice to resource management
Who this book is forIf you have worked in C++ but want to learn how to make the most of this language, especially for large projects, this book is for you. A general understanding of programming and knowledge of using an editor to produce code files in project directories is a must. Some experience with strongly typed languages, such as C and C++, is also recommended.
- Learn how to keep your development bug-free with testing and debugging
- Discover various techniques to optimize your code
Book DescriptionC++ is one of the most widely used programming languages and is applied in a variety of domains, right from gaming to graphical user interface (GUI) programming and even operating systems. If you're looking to expand your career opportunities, mastering the advanced features of C++ is key. The book begins with advanced C++ concepts by helping you decipher the sophisticated C++ type system and understand how various stages of compilation convert source code to object code. You'll then learn how to recognize the tools that need to be used in order to control the flow of execution, capture data, and pass data around. By creating small models, you'll even discover how to use advanced lambdas and captures and express common API design patterns in C++. As you cover later chapters, you'll explore ways to optimize your code by learning about memory alignment, cache access, and the time a program takes to run. The concluding chapter will help you to maximize performance by understanding modern CPU branch prediction and how to make your code cache-friendly. By the end of this book, you'll have developed programming skills that will set you apart from other C++ programmers.What you will learn - Delve into the anatomy and workflow of C++
- Study the pros and cons of different approaches to coding in C++
- Test, run, and debug your programs
- Link object files as a dynamic library
- Use templates, SFINAE, constexpr if expressions and variadic templates
- Apply best practice to resource management
Who this book is forIf you have worked in C++ but want to learn how to make the most of this language, especially for large projects, this book is for you. A general understanding of programming and knowledge of using an editor to produce code files in project directories is a must. Some experience with strongly typed languages, such as C and C++, is also recommended.
More details
Other editions
Additional editions
Gazihan Alankus | Olena Lizina | Rakesh Mane
Advanced C++
Master the technique of confidently writing robust C++ code
Book
10/2019
Packt Publishing
€54.80
Shipment within 3-4 weeks
Content
- Cover
- FM
- Copyright
- Table of Contents
- Preface
- Chapter 1: Anatomy of Portable C++ Software
- Introduction
- Managing C++ Projects
- The Code-Build-Test-Run Loop
- Building a CMake Project
- Exercise 1: Using CMake to Generate Ninja Build Files
- Importing a CMake Project into Eclipse CDT
- Exercise 2: Importing the CMake File into Eclipse CDT
- Exercise 3: Adding New Source Files to CMake and Eclipse CDT
- Activity 1: Adding a New Source-Header File Pair to the Project
- Unit Testing
- Preparing for the Unit Tests
- Exercise 4: Preparing Our Project for Unit Testing
- Building, Running, and Writing Unit Tests
- Exercise 5: Building and Running Tests
- Exercise 6: Testing the Functionality of Code
- Activity 2: Adding a New Class and Its Test
- Understanding Compilation, Linking, and Object File Contents
- Compilation and Linking Steps
- Exercise 7: Identifying Build Steps
- The Linking Step
- Diving Deeper: Viewing Object Files
- Exercise 8: Exploring Compiled Code
- Debugging C++ Code
- Exercise 9: Debugging with Eclipse CDT
- Writing Readable Code
- Indentation and Formatting
- Use Meaningful Names as Identifiers
- Keeping Algorithms Clear and Simple
- Exercise 10: Making Code Readable
- Activity 3: Making Code More Readable
- Summary
- Chapter 2A: No Ducks Allowed - Types and Deduction
- Introduction
- C++ Types
- C++ Fundamental Types
- C++ Literals
- Specifying Types - Variables
- Exercise 1: Declaring Variables and Exploring Sizes
- Specifying Types - Functions
- Exercise 2: Declaring Functions
- Pointer Types
- Exercise 3: Declaring and Using Pointers
- Creating User Types
- Enumerations
- Exercise 4: Enumerations - Old and New School
- Structures and Classes
- Fraction Class
- Constructors, Initialization, and Destructors
- Class Special Member Functions
- Implicit Versus Explicit Constructors
- Class Special Member Functions - Compiler Generation Rules
- Defaulting and Deleting Special Member Functions
- Rule of Three/Five and Rule of Zero
- Constructors - Initializing the Object
- Exercise 5: Declaring and Initializing Fractions
- Values Versus References and Const
- Exercise 6: Declaring and Using Reference Types
- Implementing Standard Operators
- Implementing the Output Stream Operator (&&)
- Structuring Our Code
- Exercise 7: Adding Operators to the Fraction Class
- Function Overloading
- Classes, Structs, and Unions
- Activity 1: Graphics Processing
- Summary
- Chapter 2B: No Ducks Allowed - Templates and Deduction
- Introduction
- Inheritance, Polymorphism, and Interfaces
- Inheritance and Access Specifiers
- Abstract Classes and Interfaces
- Exercise 1: Implementing Game Characters with Polymorphism
- Classes, Structs, and Unions Revisited
- Visibility, Lifetime, and Access
- Namespaces
- Templates - Generic Programming
- What is Generic Programming?
- Introducing C++ Templates
- C++ Pre-Packaged Templates
- Type Aliases - typedef and using
- Exercise 2: Implementing Aliases
- Templates - More than Generic Programming
- Substitution Failure Is Not An Error - SFINAE
- Floating-Point Representations
- Constexpr if Expressions
- Non-Type Template Arguments
- Exercise 3: Implementing Stringify - specialization Versus constexpr
- Function Overloading Revisited
- Template Type Deduction
- Displaying the Deduced Types
- Template Type Deduction - the Details
- SFINAE Expression and Trailing Return Types
- Class Templates
- Exercise 4: Writing a Class Template
- Activity 1: Developing a Generic "contains" Template Function
- Summary
- Chapter 3: No Leaks Allowed - Exceptions and Resources
- Introduction
- Variable Scope and Lifetime
- Exceptions in C++
- The Need for Exceptions
- Stack Unwinding
- Exercise 1: Implementing exceptions in Fraction and Stack
- What Happens When an Exception is Thrown?
- Throw-by-Value or Throw-by-Pointer
- Standard Library Exceptions
- Catching Exceptions
- Exercise 2: Implementing Exception Handlers
- CMake Generator Expressions
- Exception Usage Guidelines
- Resource Management (in an Exceptional World)
- Resource Acquisition Is Initialization
- Exercise 3: Implementing RAII for Memory and File Handles
- Special Coding Techniques
- C++ doesn't Need finally
- RAII and the STL
- Who Owns This Object?
- Temporary Objects
- Move Semantics
- Implementing a Smart Pointer
- STL Smart Pointers
- std::unique_ptr
- std::shared_ptr
- std::weak_ptr
- Smart Pointers and Calling Functions
- Exercise 4: Implementing RAII with STL Smart Pointers
- Rule of Zero/Five - A Different Perspective
- Activity 1: Implementing Graphics Processing with RAII and Move
- When is a Function Called?
- Which Function to Call
- Identifiers
- Names
- Name lookup
- Argument-Dependent Lookup
- Caveat Emptor
- Exercise 5: Implementing Templates to Prevent ADL Issues
- Implicit Conversion
- Explicit - Preventing Implicit Conversion
- Contextual Conversion
- Exercise 6: Implicit and Explicit Conversions
- Activity 2: Implementing classes for Date Calculations
- Summary
- Chapter 4: Separation of Concerns - Software Architecture, Functions, and Variadic Templates
- Introduction
- The Pointer to Implementation (PIMPL) Idiom
- Logical and Physical Dependencies
- The Pointer to Implementation (PIMPL) Idiom
- Advantages and Disadvantages of PIMPL
- Implementing PIMPL with unique_ptr&&
- unique_ptr&& PIMPL Special Functions
- Exercise 1: Implementing a Kitchen with unique_ptr&&
- Function Objects and Lambda Expressions
- Function Pointers
- What is a Function Object?
- Exercise 2: Implementing function objects
- std::function&& template
- Exercise 3: Implementing callbacks with std::function
- What is a Lambda Expression?
- Capturing data into Lambdas
- Exercise 4: Implementing Lambdas
- Variadic Templates
- Activity 1: Implement a multicast event handler
- Summary
- Chapter 5: The Philosophers' Dinner - Threads and Concurrency
- Introduction
- Synchronous, Asynchronous, and Threaded Execution
- Concurrency
- Parallelism
- Synchronous Execution
- Asynchronous Execution
- Exercise 1: Creating Threads in a Different Way
- Review Synchronization, Data Hazards, and Race Conditions
- Exercise 2: Writing an Example of Race Conditions
- Data Hazards
- RAW Dependency
- WAR Dependency
- WAW Dependency
- Resource Synchronization
- Event Synchronization
- Deadlock
- Move Semantics for Multithreading Closures
- Exercise 3: Moving Objects to a Thread Function
- Exercise 4: Creating and Working with an STL Container of Threads
- Futures, Promises, and Async
- Exercise 5: Synchronization with Future Results
- Activity 1: Creating a Simulator to Model the Work of the Art Gallery
- Summary
- Chapter 6: Streams and I/O
- Introduction
- Reviewing the I/O Portion of the Standard Library
- Predefined Standard Stream Objects
- Exercise 1: Overriding the Left Shift Operator, &&, for User-Defined Types
- File I/O Implementation Classes
- Exercise 2: Reading and Writing User-Defined Data Types to a File
- String I/O Implementation
- Exercise 3: Creating a Function for Replacement Words in a String
- I/O Manipulators
- I/O Manipulators for Changing the Numeric Base of the Stream
- Exercise 4: Displaying Entered Numbers in Different Numeric Bases
- I/O Manipulators for Floating-Point Formatting
- Exercise 5: Displaying Entered Floating-Point Numbers with Different Formatting
- I/O Manipulators for Boolean Formatting
- I/O Manipulators for Field Width and Fill Control
- I/O Manipulators for Other Numeric Formatting
- I/O Manipulators for Whitespace Processing
- Making Additional Streams
- How to Make an Additional Stream - Composition
- Exercise 6: Composing the Standard Stream Object in the User-Defined Class
- How to Make an Additional Stream - Inheritance
- Exercise 7: Inheriting the Standard Stream Object
- Leveraging Asynchronous I/O
- Asynchronous I/O on Windows Platforms
- Asynchronous I/O on Linux Platforms
- Exercise 8: Asynchronously Reading from a File in Linux
- Asynchronous Cross-Platform I/O Libraries
- Interaction of Threads and I/O
- Exercise 9: Developing a Thread-Safe Wrapper for std::cout
- Using Macros
- Activity 1: The Logging System for The Art Gallery Simulator
- Summary
- Chapter 7: Everybody Falls, It's How You Get Back Up - Testing and Debugging
- Introduction
- Assertions
- Exercise 1: Writing and Testing Our First Assertion
- Static Assertions
- Exercise 2: Testing Static Assertions
- Understanding Exception Handling
- Exercise 3: Performing Exception Handling
- Unit Testing and Mock Testing
- Exercise 4: Creating Our First Unit Test Case
- Unit Testing Using Mock Objects
- Exercise 5: Creating Mock Objects
- Breakpoints, Watchpoints, and Data Visualization
- Working with the Stack Data Structure
- Activity 1: Checking the Accuracy of the Functions Using Test Cases and Understanding Test-Driven Development (TDD)
- Summary
- Chapter 8: Need for Speed - Performance and Optimization
- Introduction
- Performance Measurement
- Manual Estimation
- Studying Generated Assembly Code
- Manual Execution Timing
- Exercise 1: Timing a Program's Execution
- Timing Programs without Side Effects
- Source Code Instrumentation
- Exercise 2: Writing a Code Timer Class
- Runtime Profiling
- Exercise 3: Using perf to Profile Programs
- Optimization Strategies
- Compiler-Based Optimization
- Loop Unrolling
- Exercise 4: Using Loop Unrolling Optimizations
- Profile Guided Optimization
- Exercise 5: Using Profile Guided Optimization
- Parallelization
- Exercise 6: Using Compiler Parallelization
- Source Code Micro Optimizations
- Using the std::vector Container Efficiently
- Exercise 7: Optimizing Vector Growth
- Short-Circuit Logical Operators
- Exercise 8: Optimizing Logical Operators
- Branch Prediction
- Exercise 9: Optimization for Branch Prediction
- Further Optimizations
- Cache Friendly Code
- Exercise 10: Exploring the Effect of Caches on Data Structures
- Exercise 11: Measuring the Impact of Memory Access
- Caching
- Prefetching
- Effects of Caching on Algorithms
- Optimizing for Cache-Friendliness
- Exercise 12: Exploring the Cost of Heap Allocations
- Struct of Arrays Pattern
- Exercise 13: Using the Struct of Arrays Pattern
- Algorithmic Optimizations
- Exercise 14: Optimizing a Word Count Program
- Activity 1: Optimizing a Spell Check Algorithm
- Summary
- Appendix
- Index
