{"id":2938,"date":"2018-05-21T20:00:34","date_gmt":"2018-05-21T18:00:34","guid":{"rendered":"https:\/\/mariusbancila.ro\/blog\/?p=2938"},"modified":"2018-05-23T15:00:51","modified_gmt":"2018-05-23T13:00:51","slug":"c-fun-strange-facts","status":"publish","type":"post","link":"https:\/\/mariusbancila.ro\/blog\/2018\/05\/21\/c-fun-strange-facts\/","title":{"rendered":"C++ fun strange facts"},"content":{"rendered":"

The title might be a little bit misleading because, on one hand, you might not find these things funny if you are stumbling upon them and not understanding what is going on, and, on the other hand, they are not really strange when you pay attention to what is going on. However, here is a list of five (randomly picked) C++ features that would probably get you giving a second thought to what’s going on.<\/p>\n

Aggregate initialization<\/h3>\n

Consider the following structure:<\/p>\n

struct foo\r\n{\r\n   foo() {}\r\n};<\/pre>\n
You can write the following:<\/p>\n
foo f1;\r\nfoo f2{};\r\nfoo f3[5];<\/pre>\n
But should you delete the default constructor as follows:<\/p>\n
struct foo\r\n{\r\n   foo() = delete;\r\n};<\/pre>\n
Then you can still intialize objects of this type but only using brace initialization (foo{}<\/tt>):<\/p>\n
foo f1;     \/\/ error: attempting to reference a deleted function\r\nfoo f2{};\r\nfoo f3[5];  \/\/ error: attempting to reference a deleted function<\/pre>\n
foo f;<\/tt> is no longer legal because foo<\/tt> does not have a default constructor anymore. However, foo f{};<\/tt> is still legal because classes with deleted default constructors can be list initialized via aggregate initialization but not value initialization. For more info see 1578. Value-initialization of aggregates<\/a>.<\/p>\n
Alternative function syntax gotchas<\/h3>\n
Alternative function syntax refers to putting the type of the return value of a function at the end after the function type, as in auto foo() noexcept -> int<\/tt>. However, it doesn’t always go as smooth as that. Let’s consider the the following base class:<\/p>\n
struct B\r\n{\r\n   virtual int foo() const noexcept;\r\n};<\/pre>\n
How do you write an overriden foo()<\/tt> in a derived class using the trailing return type (aka alternative function syntax)? If you’re tempted to do it like this then you’re wrong.<\/p>\n
struct D : B \r\n{\r\n   virtual auto foo() const noexcept override -> int;\r\n};<\/pre>\n
This will generate a compiler error (which differes depending on your compiler). The reason is that override<\/tt> is not part of the function type, so it has to be written after the function type. In other words, the correct syntax is as follows:<\/p>\n
struct D : B \r\n{\r\n   virtual auto foo() const noexcept -> int override;\r\n};<\/pre>\n
For more pros and cons on using the alternative function syntax see this article<\/a>.<\/p>\n
rvalue references and type deduction<\/h3>\n
I have updated this section to refer to universal references as forwarding references, as this is now the official term for these references, as noted by Marco Arena<\/a>. For more, see Universal vs Forwarding References in C++<\/a><\/p>\n
rvalue references are specified with &&<\/tt> but in type declaration &&<\/tt> could mean either rvalue reference or forwarding reference. The latter one is not a term that was preferred to universal reference, which was a term coined by Scott Meyers. It refers to a reference that can be either lvalue or rvalue. However, when you’re using && as parameter in function (templates) the meaning of &&<\/tt> depends on whether type deduction is involved or not; if type deduction is involved, then it is an forwarding reference; otherwise, it is an rvalue reference. Here are some examples:<\/p>\n
\r\nvoid foo(int&&);              \/\/ rvalue reference\r\n\r\ntemplate <typename T>\r\nvoid foo(T&&);                \/\/ forwarding reference\r\n\r\ntemplate <typename T>\r\nvoid foo(T const &&);         \/\/ rvalue reference;\r\n\r\ntemplate <typename T>\r\nvoid foo(std::vector<T>&&);   \/\/ rvalue reference\r\n\r\nstruct bar\r\n{\r\n   template <typename T>\r\n   void foo(T&&);             \/\/ forwarding reference\r\n};\r\n\r\ntemplate <typename T>\r\nstruct bar\r\n{\r\n   void foo(T&&);             \/\/ rvalue reference\r\n};\r\n\r\ntemplate <typename T>\r\nstruct bar\r\n{\r\n   template <typename U>\r\n   void foo(U&&);             \/\/ forwarding reference\r\n};\r\n<\/pre>\n
When you see something like T&&<\/tt> that means forwarding reference; however, if anything else is involved, like a const qualifier, such as in const T&&<\/tt>, then you have an rvalue reference. Also, if you have a std::vector<T>&&<\/tt> then you’re dealing with an rvalue reference. In this case, foo<\/tt> exists within the context of std::vector<T><\/tt>, which means T<\/tt> is already known and does not have to be deduced.<\/p>\n
There is actually a long article about this topic by Scott Meyers called Universal References in C++11<\/a>. You should read it for a detailed look at the differences and caveats of rvalue and forwarding (aka universal) references. <\/p>\n
std::array is not an array<\/h3>\n
Consider the following snippet:<\/p>\n
int main()\r\n{\r\n   std::cout << std::is_array_v<int[5]> << std::endl;\r\n   std::cout << std::is_array_v<std::array<int, 5>> << std::endl;\r\n}\r\n<\/pre>\n
What do you expect this to print? Well, the answer is 1 and 0. If you’re surprised, then remember std::array<\/tt> is not an array, but a standard fixed-length container that has the same semantics as a struct holding a C-style array T[N]<\/tt> as its only non-static data member. And, unlike a C-like array, it doesn’t decay to T*<\/tt> automatically. On the other hand, std::is_array<\/tt> is conceptually defined as follows:<\/p>\n
template<class T>\r\nstruct is_array : std::false_type {};\r\n \r\ntemplate<class T>\r\nstruct is_array<T[]> : std::true_type {};\r\n \r\ntemplate<class T, std::size_t N>\r\nstruct is_array<T[N]> : std::true_type {};<\/pre>\n
And that is why std::is_array<std::array<T, N>><\/tt> is std::false_type<\/tt>.<\/p>\n
Indexing arrays<\/h3>\n
I have to admit I only saw this a couple of times in my whole life, and although I don’t remember exactly where, it was problably some obfuscate code. The following is valid code:<\/p>\n
int arr[5]{ 1,2,3,4,5 };\r\n1[arr] = 42;<\/pre>\n
This changes the second element of arr<\/tt> (at index 1) from 2 to 42. 1[arr]<\/tt> is equivalent to arr[1]<\/tt>, which in turn is an alternative syntax for *(arr + 1)<\/tt>. Therefore, generally speaking, a[n]<\/tt> and n[a]<\/tt> are equivalent because the compiler would transform that expression in either *(a + n)<\/tt> or *(n + a)<\/tt>, which are equivalent. Therefore, all of these are valid and equivalent:<\/p>\n
int arr[5]{ 1,2,3,4,5 };\r\n\r\narr[1] = 42;\r\n1[arr] = 42;\r\n*(arr + 1) = 42;<\/pre>\n
I think it could be possible for the compiler to differentiate and make constructs such as 1[arr]<\/tt> illegal, but then again nobody actually indexes arrays like that, so I suppose it was never an issue.<\/p>\n","protected":false},"excerpt":{"rendered":"
The title might be a little bit misleading because, on one hand, you might not find these things funny if you are stumbling upon them and not understanding what is going on, and, on the other hand, they are not really strange when you pay attention to what is going on. However, here is a list of five (randomly picked) C++ features that would probably get you giving a second thought to what’s going on.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[7],"tags":[451,125,556,74],"class_list":["post-2938","post","type-post","status-publish","format-standard","hentry","category-c","tag-c","tag-fun","tag-gotchas","tag-standard"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t