What’s new in Visual Studio 2017 – C++11, C++14 and C++17

A C++ seminar for experienced software developers who want to professionally use the latest C++11, C++14 and C++17 extensions of C++ with Visual Studio 2017.

C++ has been greatly extended in recent years (C++11, C++14 and C++17). The new standard is called C++17 and makes programming with C++ easier, safer, more elegant and more efficient. The extensions include

  • new language elements such as initializer lists (which simplify initializations and check for type safety), lambda expressions (which simplify callback functions and the use of STL algorithms), simplifications in class definition, safer conversions, move semantics (which is faster), etc.
  • new classes of the standard library (STL) such as faster hash containers, smart pointers (which often avoid memory leaks), multithreading classes (for parallel execution of threads), Unicode strings, etc.
  • parallel algorithms of the standard library, which are significantly faster than before C++17 simply by specifying another argument.

These extensions are almost completely included in Visual Studio 2017 (version 15.7, since May 2018). In this seminar they are presented together with the extensions of the development environment comprehensively and compactly.

Lecturer Prof. Richard Kaiser has already held well over 100 company seminars on C# and C++. His customers include renowned global corporations and small and medium-sized enterprises. He knows the requirements of the practice and goes into detail both in the basic concepts and in the details on it.

Content

The contents (here detailed as pdf) of this course can be adapted to the wishes of the participants.

1. What’s new in the Visual Studio 2017 IDE

  • New features for the Editor, Refactoring, Debugger, Solution Explorer etc.
  • The Visual Studio C++ Core Guideline Checker

2. C++ extensions: Core features

  • The data types long long and unsigned long long
  • The null pointer literal nullptr
  • Binary Literals and Separators
  • Strongly typed enumeration types (enums)
  • inline variables
  • constexpr Values and Functions
  • Variable definitions and constexpr in if and switch
  • Type inference: Implicit type assignments with auto and decltype
  • The range-based for loop
  • Initializer lists – type-safe and uniform initialization
  • Explicit constructors and conversion functions
  • Move Semantics
    • R-value References
    • In the Standard Library
    • Implementing in Your Own Classes
  • Compile time assert: static_assert
  • What’s new for Classes
    • override, final, extended friend declarations
    • =delete and =default
    • Delegating Constructors and Implicitly Created Constructors
    • Initializer for non-static data elements
    • Attributes
    • Compiler Feature Tests
    • Macros with … (Variadic Macros)

3. Function objects and lambda expressions

  • The call operator (), predicates and arithmetic function objects
  • Binder, functional adapter
  • The function-wrapper std::function
  • Lambda expressions

4. Templates and the STL

  • Generic Functions: Function Templates
  • Generic Classes: Class Templates
  • type traits
  • Type inference in templates with decltype

5. STL algorithms and lambda expressions

  • The different types of iterators
  • Using STL algorithms with lambda expressions

6. Extensions of the standard library (STL)

  • Move semantics and optimization on the basis of type traits#
  • Extensions for Strings
  • The string classes u16string and u32string
  • conversion functions
  • “raw string Literale, Unicode String Literale
  • string_view
  • Enhancements for Container Classes
  • Iterators, memory management for vectors, emplace for containers
  • Enhancements for Stream Classes
  • Unordered Associative Containers (Hash Containers)
  • Regular expressions
  • Fixed Size Array Container
  • tuples
  • random numbers
  • New Algorithms
  • The Exception Class system_error
  • Filesystem
  • Parallel Algorithms

7. Smart pointer

  • unique_ptr
  • shared_ptr
  • weak_ptr
  • exception_ptr

8. Multithreading

  • The thread class
  • Starting Functions and Lambda Expressions as Threads
  • Exceptions in Threads
  • Pass on an exception with promise
  • Critical sections, mutexes and lock_guard
  • Atomic data types
  • Avoiding deadlocks
  • Thread-Local Variables
  • Futures, Promises and async
  • Condition variables for thread synchronization

Evaluations of participants of this seminar:

Miscellaneous:

Target group: Experienced C++ programmers who want to learn the latest state of C++ (C++11, C++14 and C++17).

Requirements: Good knowledge of C++

Teaching style: Lecture with many examples. A balanced combination of theory and practice.

At the beginning of a new topic, an overview of the application possibilities, basic ideas and syntax is described. The concepts and syntax are then illustrated using carefully selected and proven examples.

If the participants want to deepen their knowledge independently: The manuscript contains numerous practical exercises.

Flexibility: If it turns out during the seminar that the participants lack the basics or that further topics are desired, I can adapt the agenda to the participants’ wishes at any time.

Manuscript: Detailed printed training material (approx. 200 pages) – Complete text, no PowerPoint slides containing only keywords. Therefore the course material can also be used as a reference at work.

Place and time: This seminar is offered as a company seminar (in-house).

Duration: 3-5 days
Contact: see here