Book Image

Advanced C++

By : Gazihan Alankus, Olena Lizina, Rakesh Mane, Vivek Nagarajan, Brian Price
5 (1)
Book Image

Advanced C++

5 (1)
By: Gazihan Alankus, Olena Lizina, Rakesh Mane, Vivek Nagarajan, Brian Price

Overview of this book

C++ 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.

Related Content you might be interested in

Current Title:

Small book image
Advanced C++
Gazihan Alankus | Olena Lizina | Rakesh Mane | Vivek Nagarajan | Brian Price
Oct, 2019 | 762 pages
Small book image
Advanced C++ Programming Cookbook
Dr Rian Quinn
Jan, 2020 | 454 pages
Small book image
C++17 STL Cookbook
Jacek Galowicz
Jun, 2017 | 532 pages
Small book image
Modern C++ Programming Cookbook
Marius Bancila
Feb, 2024 | 816 pages
Table of Contents (11 chapters)
About the Book
About the Book
About the Authors
Learning Objectives
Audience
Approach
Hardware Requirements
Software Requirements
Installation and Setup
Installing the Code Bundle
Additional Resources
Free Chapter
1
1. Anatomy of Portable C++ Software
1. Anatomy of Portable C++ Software
Introduction
Managing C++ Projects
Importing a CMake Project into Eclipse CDT
Unit Testing
Understanding Compilation, Linking, and Object File Contents
Debugging C++ Code
Writing Readable Code
Summary
2
2A. No Ducks Allowed – Types and Deduction
2A. No Ducks Allowed – Types and Deduction
Introduction
C++ Types
Specifying Types – Variables
Specifying Types – Functions
Creating User Types
Summary
3
2B. No Ducks Allowed – Templates and Deduction
2B. No Ducks Allowed – Templates and Deduction
Introduction
Inheritance, Polymorphism, and Interfaces
Visibility, Lifetime, and Access
Templates – Generic Programming
Type Aliases – typedef and using
Templates – More than Generic Programming
Class Templates
Summary
4
3. No Leaks Allowed - Exceptions and Resources
3. No Leaks Allowed - Exceptions and Resources
Introduction
Exceptions in C++
Resource Management (in an Exceptional World)
Summary
5
4. Separation of Concerns - Software Architecture, Functions, and Variadic Templates
4. Separation of Concerns - Software Architecture, Functions, and Variadic Templates
Introduction
Function Objects and Lambda Expressions
Variadic Templates
Summary
6
5. The Philosophers' Dinner – Threads and Concurrency
5. The Philosophers' Dinner – Threads and Concurrency
Introduction
Synchronous, Asynchronous, and Threaded Execution
Review Synchronization, Data Hazards, and Race Conditions
Futures, Promises, and Async
Summary
7
6. Streams and I/O
6. Streams and I/O
Introduction
Summary
8
7. Everybody Falls, It's How You Get Back Up – Testing and Debugging
7. Everybody Falls, It's How You Get Back Up – Testing and Debugging
Introduction
Unit Testing and Mock Testing
Summary
9
8. Need for Speed – Performance and Optimization
8. Need for Speed – Performance and Optimization
Introduction
Performance Measurement
Runtime Profiling
Optimization Strategies
Further Optimizations
Cache Friendly Code
Summary
Appendix
Appendix
Chapter 1 - Anatomy of Portable C++ Software
Chapter 2A - No Ducks Allowed – Types and Deduction
Chapter – 2B - No Ducks Allowed – Templates and Deduction
Chapter 3 - The Distance between Can and Should – Objects, Pointers and Inheritance
Activity 2: Implementing classes for Date Calculations
Chapter 4 - Separation of Concerns - Software Architecture, Functions, Variadic Templates
Chapter 5 - The Philosophers' Dinner – Threads and Concurrency
Chapter 6 – Streams and I/O
Chapter 7 - Everybody Falls, It's How You Get Back Up – Testing and Debugging
Chapter 8 - Need for Speed – Performance and Optimization

Summary

In this chapter, we explored the lifetime of variables - both automatic and dynamic, where they are stored, and when they are destructed. We then used this information to develop RAII techniques that allow us to almost ignore resource management because the automatic variables will clean them up when they are destructed even in the presence of an exception. Then, we looked at throwing exceptions and catching them so that we can deal with abnormal conditions at the right level. From RAII, we went into a discussion on the ownership of resources and how STL smart pointers help us in this area. We discovered that just about everything is treated as a function call, thus allowing operator overloading and implicit conversions. We discovered the wonderful (or is it awful?) world of argument-dependent lookup (ADL) and how it can potentially trip us up in the future. We now have a good understanding of the fundamental features of C++. In the next chapter we will start to explore function...

Previous Section
End of Chapter 4
Next Chapter