![\"Metamorphosis](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/02\/Metamorphosis_frog_Meyers.png\")
<\/p>\nWhat has narrowing conversion and casts in common? They are often the source of errors; therefore, I will write about them today.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
Here are the rules from the guidelines.<\/p>\n
const<\/code><\/a><\/li>\n- ES.55: Avoid the need for range checking<\/a><\/li>\n<\/ul>\n
Narrowing conversion is a conversion of a value, including the loss of its precision. Most of the time that is not what you want.<\/p>\n
ES.46: Avoid narrowing conversions<\/a><\/h3>\nHere are a few examples from the guidelines.<\/p>\n
\ndouble<\/span> d =<\/span> 7.9<\/span>;\r\nint<\/span> i =<\/span> d; \/\/ bad: narrowing: i becomes 7<\/span>\r\ni =<\/span> (int<\/span>) d; \/\/ bad: we're going to claim this is still not explicit enough<\/span>\r\n\r\nvoid<\/span> f<\/span>(int<\/span> x, long<\/span> y, double<\/span> d)\r\n{\r\n char<\/span> c1 =<\/span> x; \/\/ bad: narrowing<\/span>\r\n char<\/span> c2 =<\/span> y; \/\/ bad: narrowing<\/span>\r\n char<\/span> c3 =<\/span> d; \/\/ bad: narrowing<\/span>\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
If you want a narrowing conversion, you should do it explicitly, not implicitly, according to the Python rule from The Zen of Python<\/a>: Explicit is better than implicit<\/em>.<\/strong> The guideline support library (GSL) has two casts to express your intent: gsl::narrow_cast<\/span> and gsl::narrow.<\/span><\/p>\n\ndouble<\/span> d =<\/span> 7.9<\/span>;\r\ni =<\/span> narrow_cast<<\/span>int<\/span>><\/span>(d); \/\/ OK (you asked for it): narrowing: i becomes 7<\/span>\r\ni =<\/span> narrow<<\/span>int<\/span>><\/span>(d); \/\/ OK: throws narrowing_error<\/span>\r\n<\/pre>\n<\/div>\n <\/p>\n
The gsl::narrow_cast<\/span> performs the cast, and the gsl::narrow<\/span> cast throws an exception if a narrowing conversion happens.<\/p>\nMost of the time, a narrowing conversion happened secretly. How can you protect yourself from this? Use the power of the curly braces:<\/p>\n
\n\/\/ suppressNarrowingConversion.cpp<\/span>\r\n\r\nvoid<\/span> f<\/span>(int<\/span> x, long<\/span> y, double<\/span> d){\r\n char<\/span> c1 =<\/span> {x}; \r\n char<\/span> c2 =<\/span> {y}; \r\n char<\/span> c3 =<\/span> {d}; \r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n double<\/span> d =<\/span> {7.9<\/span>}; \r\n int<\/span> i =<\/span> {d}; \r\n\r\n f(3<\/span>, 3l<\/span>, 3.0<\/span>);\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
All initializations are put into curly braces. According to the C++11 standard, the compiler has to warn you if a narrowing conversion happens.<\/span><\/p>\n ![\"narrowingConversion\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/02\/narrowingConversion.png\")
<\/p>\n
Explicit is better than implicit<\/em>. This will not hold a C-cast.<\/p>\n<\/p>\nES.48: Avoid casts<\/a><\/h3>\nLet’s see what will happen if we screw up the type of system.<\/p>\n
\n\/\/ casts.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n double<\/span> d =<\/span> 2<\/span>;\r\n auto<\/span> p =<\/span> (long<\/span>*<\/span>)&<\/span>d;\r\n auto<\/span> q =<\/span> (long<\/span> long<\/span>*<\/span>)&<\/span>d;\r\n std::<\/span>cout <<<\/span> d <<<\/span> ' '<\/span> <<<\/span> *<\/span>p <<<\/span> ' '<\/span> <<<\/span> *<\/span>q <<<\/span> '\\n'<\/span>;\r\n \r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Neither the result with the Visual Studio compiler<\/p>\n
![\"castsWin\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/02\/castsWin.png\")
<\/p>\n
nor the result with the GCC or the clang compiler is promising.<\/p>\n
<\/p>\n
![\"castsGccClang\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/02\/castsGccClang.png\")
<\/p>\n
<\/p>\n
What is bad about the C-cast? You don’t see which cast is performed. If you perform a C-cast, a combination of casts will be applied if necessary. Roughly speaking, a C-cast starts with a static_cast<\/span>, continues with a const_cast<\/span>, and finally performs a reinterpret_cast.<\/span><\/p>\nOf course, you know how I will continue: explicit is better than implicit.<\/em><\/p>\nES.49: If you must use a cast, use a named cast<\/a><\/h3>\nIncluding the GSL, C++ offers eight different named casts. Here are including a short description:<\/p>\n
\n- static_cast: <\/span>conversion between similar types such as pointer types or numeric types<\/li>\n
- const_cast: <\/span>adds or removes const or volatile <\/li>\n
- reinterpret_cast: <\/span>converts between pointers or between integral types and pointers<\/li>\n
- dynamic_ cast: <\/span>converts between polymorph pointers or references in the same class hierarchy<\/li>\n
- std::move: <\/span>converts to an rvalue reference<\/li>\n
- std::forward: <\/span>converts to an rvalue reference<\/li>\n
- gsl::narrow_cast: applies<\/span> a static_cast<\/span><\/li>\n
- gsl::narrow: applies <\/span>a static_cast<\/span><\/li>\n<\/ul>\n
What? std::move<\/span> and std::forward<\/span> are casts? Le’s have a closer look at the internals of std::move: <\/span><\/p>\n\nstatic_cast<\/span><<\/span>std::<\/span>remove_reference<decltype(arg)<\/span>>::<\/span>type&&><\/span>(arg)\r\n<\/pre>\n<\/div>\n <\/p>\n
First, the type of argument arg<\/span> is determined by decltype(arg)<\/span>. Then all references are removed, and two new references are added. The function std::remove_reference<\/span> is from the type-traits library. I have already written a few posts to the type-traits library.<\/a> In the end, we will always get an rvalue reference. <\/p>\n