New features in old language
A u8 character literal
In C++17 was added new character literal for UTF-8.
For example:
|
1 2 3 4 5 |
int main() { auto c = u8'a'; return 0; } |
It’s used for correct translation characters to ASCII on different platforms.
Hexadecimal floating point literals
In C++17 was added hexadecimal floating point literals.
|
1 |
double d = 0x1.2p3; // hex fraction 1.2 (decimal 1.125) scaled by 2^3, that is 9.0 |
Link for cppreference.
Fold expressions is the extension for already introduced variadic templates in C++11.
It allows to pack and unpack template parameters in unary and binary operations.
For example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
template<typename ... Args> auto Sum(Args... args) { return (args + ...);} template<typename ... Args> bool all(Args ... args) { return (args && ...);} template<typename ... Args> void printer(Args ... args){ (std::cout << ... << args) << std::endl; } int main() { std::cout << all(true, true, true) << std::endl; printer(1, 2, 3); std::cout << Sum(1, 2, 3, 4, 5) << std::endl; return 0; } |
Example with pushing values:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
template<typename T, typename ... Args> void push_all(std::vector<T>& vector, Args ... args) { (vector.push_back(args), ...); } int main() { std::vector<int> vector_ = { 1, 2, 3, 4, 5 }; push_all(vector_, 1, 1, 1, 2,22, 2,2); for (auto value : vector_) std::cout << value << " "; return 0; } |
std::any
Any class can hold any type of object. It’s type safe container for single values of any type. A better way to handle any type and replace void*.
Type requeirments:
std::decay_t<T> – must be CopyConstructable
Example:
|
1 2 3 |
std::any x = 1; x = 0.111; x = “123”; |
To get value from std::any you need to use std::any_cast.
|
1 2 |
std::any x= 10; std::cout << std::any_cast<int>(x) << std::endl; |
In case if type in std::any_cast is wrong will be called std::bad_any_cast exception.
|
1 2 3 |
auto k = std::any(12); std::cerr << std::any_cast<int>(k) << std::endl; // ok std::cerr << std::any_cast<std::string>(k) << std::endl; // error - bad_any_cast |
Continue reading “C++17: new types: std::any, std::optional, std::variant”
std::string_view it’s class which can view std::string or const char* without ownership and without additional memory requesting.
SSO (Small string optimization)
std::string has optimization for small strings ( compiler specific feature, for gcc, clang and msvc there are different values ).
For example for GCC 7.3 this value is 16 bytes. If string has <=16 bytes it will be saved in stack inside std::string object. If more then 16 bytes, then data used for saving string will be in heap. Which means additional memory allocations.
|
1 2 |
std::string str(“123”); // no additional memory allocations std::string str(“1111111111111111111111111111111111111111”); // additional memory allocations |
It can be checked by overloading operator new in global space.
|
1 2 3 4 |
void* operator new(std::size_t count) { std::cout << count << “ bytes” << std::endl; return malloc(count); } |
In C++17 there is couple changes to behavior of things which were already in C++.
1 ) auto x{ 1 } – now it’s int value, not initializer_list.
For a braced-init-list with only a single element, auto
deduction will deduce from that entry;
For a braced-init-list with more than one element, auto
deduction will be ill-formed.
For example:
|
1 2 3 4 5 |
auto x1 = { 1, 2 }; // decltype(x1) is std::initializer_list<int> auto x2 = { 1, 2.0 }; // error: cannot deduce element type auto x3{ 1, 2 }; // error: not a single element auto x4 = { 3 }; // decltype(x4) is std::initializer_list<int> auto x5{ 3 }; // decltype(x5) is int |
Standard paper related to this changes: n3922.
Parallel algorithms implementation it’s a new feature of C++17 standard. Which allow to use simple STL functions in multiple threads.
At the moment (17.07.2018) only one compiler supports Parallel Algorithms. It’s Visual Studio 2017 ( versions 15.3 and higher).
To build C++ projects with parallel STL you need to build with a flag:
/std:c++17
In C++17 we have a new term – Execution policy
It’s the first parameter to parallel functions from STL. It allows you to choose, how can be function executed. To use it you need to include
#include <execution>
Types of execution policy:
std::seq – without using threads or vectorization, sequenced instructions. This is a default value.
std::par – parallel execution with using threads. When using parallel execution policy, it is the programmer’s responsibility to avoid deadlocks.
std::par_unseq – parallel execution using threads and vectorization or migrating across threads(such as by parent-stealing scheduler). Functions with this policy are permitted to execute in unordered fashion in unspecified threads and unsequenced with other threads.
1 – Trigraphs
Trigraphs were removed from C++17 because they are not needed anymore. They were used in C/C++ in 80-s. Because the old coding table not supported all needed symbols ISO/IEC646 like: # , [ , ]. etc.
| Trigraph | Equivalent symbol |
| ??= | # |
| ??/ | \ |
| ??’ | ^ |
| ??( | [ |
| ??) | ] |
| ??! | | |
| ??< | { |
| ??> | } |
| ??- | ~ |
Also even before C++17 GCC compiler show warning when trigraphs were used, because using trigraphs can turn to unexpected behavior, for example: