New features in old language
Inline variables
For now, it’s possible to specify variables as inline.
For example:
|
1 2 3 4 |
class B { public: inline static const int x{ 10 }; }; |
it allows keep it only in a header, without adding to cpp static variable.
constexpr variables have implicit inline.
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); } |