Agenda of Our Forthcoming Modern C++ Webinar

Dmitri Nesteruk

Hi, everyone!

On July 2^nd, we plan to run a webinar covering some of the features of Modern C++. Modern C++ is a really broad topic, so here is an outline of some of the things we are going to cover:

• Useful new C++ constructs, such as in-class variable initializers, delegating constructors and deleted/defaulted functions as well as raw strings, nullptr and others.
• Uniform initialization, which simplifies the, ahem, initialization of various objects (e.g., obviating some constructor calls in function return values) and also helps us avoid C++’s most vexing parse. Also introduced is the concept of initializer lists.
• Automatic type deduction with auto and decltype keywords drastically reduce the amount of code one has to write, and also help us write powerful generic code.
• The override and final keywords help us control that we are, in fact, overriding a function, or preventing a function from being overridden.
• Lambdas allow us to easily define anonymous functions instead of building old-fashioned functors. They also happen to be more powerful in C++ than in C#/Java: you can, for example, control which variables get captured and how.
• Strongly typed enumerations prevent their elements from polluting their immediate declaration scope and offer additional safety.
• Non-member begin()/end() functions simplify writing algorithms that can operate on different collections (e.g., array or vector) and a range-based for loop, especially coupled with auto, makes iterating collections a lot easier.
• constexpr and static asserts allow us to perform compile-time evaluations, whereas type traits let us intelligently constrain template parameters.
• Variadic templates let you write functions with variable number of arguments of any types, resulting in neat things such as the super-useful tie function that finally lets us extract tuple values in a single statement and without those ugly get<>() calls.
• Smart pointers have come a long way since the days of auto_ptr. We’ll talk about the common types (shared_ptr, unique_ptr and weak_ptr) and their uses.
• Finally, we shall talk about rvalue references and move semantics that help us avoid needless creation of temporary objects. We’ll cover std::move and how to write your own move constructors and assignment operators.

So these are some of the things we are going to talk about in the webinar. If you haven’t registered for the webinar yet, please register here and we’ll see you on July 2^nd! ■

Subscribe to CLion Blog updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!