As you know, the C++ language is the brain child of Bjarne Stroustrup, who developed C++ in 1979. The C++ programming language is standardized by International Organization for Standardization (ISO).
The initial standardization was published in 1998, commonly referred to as C++98, and the next standardization C++03 was published in 2003, which was primarily a bug fix release with just one language feature for value initialization. In August 2011, the C++11 standard was published with several additions to the core language, including several significant interesting changes to the Standard Template Library (STL); C++11 basically replaced the C++03 standard. C++14 was published in December, 2014 with some new features, and later, the C++17 standard was published on July 31, 2017.
At the time of writing this book, C++17 is the latest revision of the ISO/IEC standard for the C++ programming language.
This chapter requires a compiler that supports C++17 features: gcc version 7 or later. As gcc version 7 is the latest version at the time of writing this book, I'll be using gcc version 7.1.0 in this chapter.
The complete list of C++17 features can be found at http://en.cppreference.com/w/cpp/compiler_support#C.2B.2B17_features.
To give a high-level idea, the following are some of the new C++17 features:
- New auto rules for direct-list-initialization
static_assert
with no messages- Nested namespace definition
- Inline variables
- Attributes for namespaces and enumerators
- C++ exceptions specifications are part of the type system
- Improved lambda capabilities that give performance benefits on servers
- NUMA architecture
- Using attribute namespaces
- Dynamic memory allocation for over-aligned data
- Template argument deduction for class templates
- Non-type template parameters with auto type
- Guaranteed copy elision
- New specifications for inheriting constructors
- Direct-list-initialization of enumerations
- Stricter expression evaluation order
shared_mutex
- String conversions
Otherwise, there are many new interesting features that were added to the core C++ language: STL, lambadas, and so on. The new features give a facelift to C++, and starting from C++17
, as a C++ developer, you will feel that you are working in a modern programming language, such as Java or C#.
The following features are now removed in C++17:
- The
register
keyword was deprecated in C++11 and got removed in C++17 - The
++
operator forbool
was deprecated in C++98 and got removed in C++17 - The dynamic exception specifications were deprecated in C++11 and and got removed in C++17
Let's explore the following C++17 key features one by one in the following sections:
- Easier nested namespace
- New rules for type detection from the braced initializer list
- Simplified
static_assert
std::invoke
- Structured binding
- The
if
andswitch
local-scoped variables - Template type auto-detection for class templates
- Inline variables
Until the C++14 standard, the syntax supported for a nested namespace in C++ was as follows:
#include <iostream> using namespace std; namespace org { namespace tektutor { namespace application { namespace internals { int x; } } } } int main ( ) { org::tektutor::application::internals::x = 100; cout << "\nValue of x is " << org::tektutor::application::internals::x << endl; return 0; }
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output of the preceding program is as follows:
Value of x is 100
Every namespace level starts and ends with curly brackets, which makes it difficult to use nested namespaces in large applications. C++17 nested namespace syntax is really cool; just take a look at the following code and you will readily agree with me:
#include <iostream>
using namespace std;
namespace org::tektutor::application::internals {
int x;
}
int main ( ) {
org::tektutor::application::internals::x = 100;
cout << "\nValue of x is " << org::tektutor::application::internals::x << endl;
return 0;
}
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output remains the same as the previous program:
Value of x is 100
C++17 introduced new rules for auto-detection of the initializer list, which complements C++14 rules. The C++17 rule insists that the program is ill-formed if an explicit or partial specialization of std::initializer_list
is declared:
#include <iostream> using namespace std; template <typename T1, typename T2> class MyClass { private: T1 t1; T2 t2; public: MyClass( T1 t1 = T1(), T2 t2 = T2() ) { } void printSizeOfDataTypes() { cout << "\nSize of t1 is " << sizeof ( t1 ) << " bytes." << endl; cout << "\nSize of t2 is " << sizeof ( t2 ) << " bytes." << endl; } }; int main ( ) { //Until C++14 MyClass<int, double> obj1; obj1.printSizeOfDataTypes( ); //New syntax in C++17 MyClass obj2( 1, 10.56 ); return 0; }
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output of the preceding program is as follows:
Values in integer vectors are ... 1 2 3 4 5 Values in double vectors are ... 1.5 2.5 3.5
The static_assert
macro helps identify assert failures during compile time. This feature has been supported since C++11; however, the static_assert
macro used to take a mandatory assertion failure message till, which is now made optional in C++17.
The following example demonstrates the use of static_assert
with and without the message:
#include <iostream> #include <type_traits> using namespace std; int main ( ) { const int x = 5, y = 5; static_assert ( 1 == 0, "Assertion failed" ); static_assert ( 1 == 0 ); static_assert ( x == y ); return 0; }
The output of the preceding program is as follows:
g++-7 staticassert.cpp -std=c++17 staticassert.cpp: In function ‘int main()’: staticassert.cpp:7:2: error: static assertion failed: Assertion failed static_assert ( 1 == 0, "Assertion failed" ); staticassert.cpp:8:2: error: static assertion failed static_assert ( 1 == 0 );
From the preceding output, you can see that the message, Assertion failed
, appears as part of the compilation error, while in the second compilation the default compiler error message appears, as we didn't supply an assertion failure message. When there is no assertion failure, the assertion error message will not appear as demonstrated in static_assert ( x == y )
. This feature is inspired by the C++ community from the BOOST C++ library.
The std::invoke()
method can be used to call functions, function pointers, and member pointers with the same syntax:
#include <iostream> #include <functional> using namespace std; void globalFunction( ) { cout << "globalFunction ..." << endl; } class MyClass { public: void memberFunction ( int data ) { std::cout << "\nMyClass memberFunction ..." << std::endl; } static void staticFunction ( int data ) { std::cout << "MyClass staticFunction ..." << std::endl; } }; int main ( ) { MyClass obj; std::invoke ( &MyClass::memberFunction, obj, 100 ); std::invoke ( &MyClass::staticFunction, 200 ); std::invoke ( globalFunction ); return 0; }
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output of the preceding program is as follows:
MyClass memberFunction ... MyClass staticFunction ... globalFunction ...
The std::invoke( )
method is a template function that helps you seamlessly invoke callable objects, both built-in and user-defined.
You can now initialize multiple variables with a return value with a really cool syntax, as shown in the following code sample:
#include <iostream>
#include <tuple>
using namespace std;
int main ( ) {
tuple<string,int> student("Sriram", 10);
auto [name, age] = student;
cout << "\nName of the student is " << name << endl;
cout << "Age of the student is " << age << endl;
return 0;
}
In the preceding program, the code highlighted in bold is the structured binding feature introduced in C++17. Interestingly, we have not declared the string name
and int age
variables. These are deduced automatically by the C++ compiler as string
and int
, which makes the C++ syntax just like any modern programming language, without losing its performance and system programming benefits.
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output of the preceding program is as follows:
Name of the student is Sriram Age of the student is 10
There is an interesting new feature that allows you to declare a local variable bound to the if
and switch
statements' block of code. The scope of the variable used in the if
and switch
statements will go out of scope outside the respective blocks. It can be better understood with an easy to understand example, as follows:
#include <iostream> using namespace std; bool isGoodToProceed( ) { return true; } bool isGood( ) { return true; } void functionWithSwitchStatement( ) { switch ( auto status = isGood( ) ) { case true: cout << "\nAll good!" << endl; break; case false: cout << "\nSomething gone bad" << endl; break; } } int main ( ) { if ( auto flag = isGoodToProceed( ) ) { cout << "flag is a local variable and it loses its scope outside the if block" << endl; } functionWithSwitchStatement(); return 0; }
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output of the preceding program is as follows:
flag is a local variable and it loses its scope outside the if block All good!
I'm sure you will love what you are about to see in the sample code. Though templates are quite useful, a lot of people don't like it due to its tough and weird syntax. But you don't have to worry anymore; take a look at the following code snippet:
#include <iostream> using namespace std; template <typename T1, typename T2> class MyClass { private: T1 t1; T2 t2; public: MyClass( T1 t1 = T1(), T2 t2 = T2() ) { } void printSizeOfDataTypes() { cout << "\nSize of t1 is " << sizeof ( t1 ) << " bytes." << endl; cout << "\nSize of t2 is " << sizeof ( t2 ) << " bytes." << endl; } }; int main ( ) { //Until C++14 MyClass<int, double> obj1; obj1.printSizeOfDataTypes( ); //New syntax in C++17 MyClass obj2( 1, 10.56 ); return 0; }
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output of the program is as follows:
Size of t1 is 4 bytes. Size of t2 is 8 bytes.
Just like the inline function in C++, you could now use inline variable definitions. This comes in handy to initialize static variables, as shown in the following sample code:
#include <iostream> using namespace std; class MyClass { private: static inline int count = 0; public: MyClass() { ++count; } public: void printCount( ) { cout << "\nCount value is " << count << endl; } }; int main ( ) { MyClass obj; obj.printCount( ) ; return 0; }
The preceding code can be compiled and the output can be viewed with the following commands:
g++-7 main.cpp -std=c++17 ./a.out
The output of the preceding code is as follows:
Count value is 1
In this chapter, you got to know interesting new features introduced in C++17. You learned the super simple C++17 nested namespace syntax. You also learned datatype detection with a braced initializer list and the new rule imposed in the C++17 standard.
You also noticed that static_assert
can be done without assert failure messages. Also, using std::invoke()
, you can now invoke global functions, function pointers, member functions, and static class member functions. And, using structured binding, you could now initialize multiple variables with a return value.
You also learned that the if
and switch
statements can have a local-scoped variable right before the if
condition and switch
statements. You learned about auto type detection of class templates. Lastly, you used inline
variables.
There are many more C++17 features, but this chapter attempts to cover the most useful features that might be required for most of the developers. In the next chapter, you will be learning about the Standard Template Library.