{"id":110324,"date":"2024-09-30T07:00:00","date_gmt":"2024-09-30T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=110324"},"modified":"2024-09-30T08:54:55","modified_gmt":"2024-09-30T15:54:55","slug":"20240930-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20240930-00\/?p=110324","title":{"rendered":"Pulling a single item from a C++ parameter pack by its index, remarks"},"content":{"rendered":"

In my earlier discussion of pulling a single item from a C++ parameter pack by its index<\/a>, I noted that with the Pack Indexing<\/a> proposal, you would be able to write this to pull an item from a parameter pack while preserving its reference category.<\/p>\n

template<int index, typename...Args>\r\nvoid example(Args&&... args)\r\n{\r\n    auto&& arg = (Args...[index]&&)args...[index];\r\n    using Arg = Args...[index]&&;\r\n}\r\n<\/pre>\n
 Why did I need to apply the (Args...[index]&&)<\/code> cast<\/a>? Why can’t I just write this:<\/p>\n
    auto&& arg = args...[index];\r\n<\/pre>\n
or possibly<\/p>\n
    decltype(auto) arg = args...[index];\r\n<\/pre>\n
Well, when you write the name of a variable, the result is an lvalue reference, even if the variable is an rvalue reference<\/i>. Watch:<\/p>\n
struct S\r\n{\r\n    S(S&); \/\/ construct from lvalue\r\n    S(S&&); \/\/ construct from rvalue\r\n};\r\n\r\nvoid whathappens(S&& s)\r\n{\r\n    S t = s; \/\/ which will it use?\r\n}\r\n<\/pre>\n
Try it out in your favorite compiler. This code constructs from an lvalue<\/i> reference. Even though s<\/code> is an rvalue reference, when you say its name, you get an lvalue reference, so that’s the construtor that gets selected.<\/p>\n
You sort of knew this already. For example, you can’t take the address of an rvalue reference, but you can write this:<\/p>\n
void whathappens(int&& v)\r\n{\r\n    int* p = &v; \/\/ legal!\r\n}\r\n<\/pre>\n
And you’ve been writing std::move<\/code> to say “It’s okay to move from this object.”<\/p>\n
void whathappens(S&& s)\r\n{\r\n    S t = std::move(s); \/\/ force rvalue\r\n}\r\n<\/pre>\n
I mean, that’s why you’ve been writing std::move<\/code> and std::forward<\/code> all these years. If writing s<\/code> already produced an rvalue reference, then there would be no need to std::move<\/code> or std::forward<\/code> it.<\/p>\n
“Okay, I get it. Writing the name of a variable that represents an rvalue reference produces an lvalue. So what?”<\/p>\n
Since writing the name of the variable produces an lvalue reference, decltype(auto)<\/code> sees that the right hand side is an lvalue reference, so it deduces an lvalue reference.<\/p>\n
Now, you could say “Well, sure, but let’s make a special case for indexed elements from a parameter pack, so that saying their name produces an rvalue reference if the corresponding parameter is an rvalue.” But that creates another weird special case in C++, and C++ is hard enough to language-lawyer without adding even more<\/i> weird special cases.\u00b9<\/p>\n
Bonus chatter<\/b>: Instead of<\/p>\n
    auto&& arg = (Args...[index]&&)args...[index];\r\n<\/pre>\n
I could also have written<\/p>\n
    auto&& arg = std::forward<Args...[index]>(args...[index]);\r\n<\/pre>\n
which is wordier but probably clearer. I was sort of assuming people understood this common shortcut.<\/p>\n
\u00b9 I generally believe in the principle that it is better to have a set of simple rules that are easy to understand and explain, even if it means that some scenarios are awkward or suboptimal, as opposed to a set of rules that cover all scenarios but which are so complex that nobody can understand them, much less explain them.<\/p>\n","protected":false},"excerpt":{"rendered":"
Why such a complicated way to pull the type from the pack?<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-110324","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Why such a complicated way to pull the type from the pack?<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110324","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=110324"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110324\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=110324"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=110324"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=110324"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}