{"id":666,"date":"2017-10-21T03:25:09","date_gmt":"2017-10-21T03:25:09","guid":{"rendered":"http:\/\/www.rangakrish.com\/?p=666"},"modified":"2017-10-21T07:52:10","modified_gmt":"2017-10-21T07:52:10","slug":"c17-initalization-in-selection-statements","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2017\/10\/21\/c17-initalization-in-selection-statements\/","title":{"rendered":"C++17: Initialization in Selection Statements"},"content":{"rendered":"

C++17 enhances if<\/strong><\/em> and switch<\/strong><\/em> statements with the ability to define\u00a0 variables whose life-time is limited to the corresponding scope. This is in keeping with the general guideline that variables should have a tight<\/strong><\/em> scope, i.e.,\u00a0 should be defined as close to the point of use as possible and should not live beyond where they are really needed.<\/p>\n

What are the main benefits of such a tight scoping?<\/p>\n

– Name pollution is under control<\/p>\n

– As per RAII<\/strong><\/em><\/a>, acquired resources are released as early as possible<\/p>\n

Prior to C++17, it was possible to define variables in the if<\/strong><\/em> statement, but with the condition that for user-defined types, the type must define either operator bool()<\/strong><\/em> or operator void *()<\/strong><\/em>. C++17 removes this requirement and makes initialization much more simpler and straightforward.<\/p>\n

Let us consider the following struct as an example:<\/p>\n

\"Sample<\/a>
Sample Class<\/strong><\/figcaption><\/figure>\n

An object of this type\u00a0X<\/strong><\/em> is constructed by passing an integer argument. It is a valid initialization if the argument passed is less than 1000, else it is invalid. By the way, this struct has been defined merely to illustrate our idea, and has no other significance.<\/p>\n

Take a look at the following function:<\/p>\n

\"Pre-C++17<\/a>
Pre-C++17 Usage<\/strong><\/figcaption><\/figure>\n

It shows the initialization feature available prior to C++17. Notice how we create an object of type\u00a0X<\/strong><\/em> within the condition part of if<\/strong><\/em> statement. The scope of the object is just this if<\/strong><\/em> statement, extending to the true<\/strong><\/em> and false<\/strong><\/em> segments of the code.<\/p>\n

So how do we know if the initialization is treated as true<\/strong><\/em> or false<\/strong><\/em>? According to the standard, if the class has operator bool()<\/strong> <\/em>function, then it will be automatcialy invoked after the object is constructed and\u00a0 if that operator returns true<\/strong><\/em>, then the condition evaluates to true<\/strong><\/em>, else it is false<\/strong><\/em>. If the class does not define operator bool()<\/strong><\/em>, but defines operator void *()<\/strong><\/em>, then this function will be invoked after construction. If this returns nullptr<\/strong><\/em>, the condition is treated as false<\/strong><\/em>, else it is true<\/strong><\/em>. What if both functions are defined? In that case, operator bool()<\/strong><\/em> will be called. What if neither is defined? Then it is a compile-time error!<\/p>\n

Here is the output from the program:<\/p>\n

operator bool called<\/strong><\/em><\/span><\/p>\n

Object x_true inited successfully<\/strong><\/em><\/span><\/p>\n

operator bool called<\/strong><\/em><\/span><\/p>\n

Object x_false initialization failed<\/strong><\/em><\/span><\/p>\n

You can see that even though both the operator functions are present, the compiler calls operator bool()<\/strong><\/em>. The result is as expected.<\/p>\n

Now, what has changed in C++17? The logic has been considerably simplified by introducing a syntax extension to the if<\/strong><\/em> statement. Before showing how to take advantage of the new extension, I want to mention that switch<\/strong><\/em> statement too has been enhanced in this context.<\/p>\n

\"C++17<\/a>
C++17 Model<\/strong><\/figcaption><\/figure>\n

As is evident, the if<\/strong><\/em> condition can now contain two parts. The first part is the actual initialization (can be skipped if you do not want to initialize any object here) and the second part is the condition part. This is neat because we do not require operator bool()<\/strong><\/em> or operator void *()<\/strong><\/em> function to tell us if the initialization is successful.\u00a0 The condition part can directly access an appropriate element of the object to trigger the branch to be taken.<\/p>\n

Here is the output:<\/p>\n

Object x1 inited successfully<\/strong><\/em><\/span><\/p>\n

Object x2 initialization failed<\/strong><\/em><\/span><\/p>\n

Object xobj at LEVEL3<\/strong><\/em><\/span><\/p>\n

Neat, eh?<\/p>\n

Object initialization in selection statements, as explained above, is not that common, but I feel it deserves more attention. C++17 makes this usage much more palatable.<\/p>\n

I tested this code in Visual Studio Professional 2017, version 15.4.0<\/strong><\/em>. The source code is available here<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"

C++17 enhances if and switch statements with the ability to define\u00a0 variables whose life-time is limited to the corresponding scope. This is in keeping with the general guideline that variables should have a tight scope, i.e.,\u00a0 should be defined as close to the point of use as possible and should not live beyond where they […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[49,17],"tags":[118,119,120],"class_list":["post-666","post","type-post","status-publish","format-standard","hentry","category-c","category-programming","tag-c17","tag-initializer","tag-selection-statements"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-aK","jetpack-related-posts":[{"id":3230,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/10\/15\/c20-constinit-specifier\/","url_meta":{"origin":666,"position":0},"title":"C++20: \u201cconstinit\u201d Specifier","author":"admin","date":"October 15, 2023","format":false,"excerpt":"The constinit specifier, introduced in C++20, is applied to static variables (global and local static) and thread local variables, with the requirement that they either have a zero initialization or they are initialized with a compile-time constant expression. Here is our first example: Line 17 declares a global constinit variable,\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Example-1: Basic Types","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/10\/case1-300x178.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":717,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/12\/03\/c17-stdany\/","url_meta":{"origin":666,"position":1},"title":"C++17: std::any","author":"admin","date":"December 3, 2017","format":false,"excerpt":"In the previous two posts, I talked about std::variant<> and std::optional<>. Today, I want to take up std::any for discussion. The type any (implemented by the class any) allows a variable to hold a single value of any type. More interestingly, the type of the value held by a variable\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Example1","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/12\/Example1.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/12\/Example1.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/12\/Example1.png?resize=525%2C300 1.5x"},"classes":[]},{"id":193,"url":"https:\/\/www.rangakrish.com\/index.php\/2016\/03\/27\/user-defined-literals-in-c\/","url_meta":{"origin":666,"position":2},"title":"User-defined Literals in C++","author":"admin","date":"March 27, 2016","format":false,"excerpt":"C++11 introduced user-defined literals, allowing programmers to define special suffixes that can be associated with the built-in literal types: character, integer, float, boolean, and pointer. When designed and used properly, these provide nice syntactic sugar facilitating readability and at the same time, increasing type safety. For example, I can define\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"User-defined Literal","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/03\/User-defined-Literal.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/03\/User-defined-Literal.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2016\/03\/User-defined-Literal.png?resize=525%2C300 1.5x"},"classes":[]},{"id":1905,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/03\/04\/deleted-destructor-in-c\/","url_meta":{"origin":666,"position":3},"title":"Deleted Destructor in C++","author":"admin","date":"March 4, 2020","format":false,"excerpt":"Since C++ 11, we can use the keyword delete to declare functions as deleted and thus prohibit the use of these functions in the code. See this article\u00a0for a brief overview. In particular, the destructor of a class\/struct\/union can be declared as deleted. In today\u2019s article, I am going to\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Example-8","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example-8.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":3184,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/08\/13\/stdis_scoped_enum\/","url_meta":{"origin":666,"position":4},"title":"std::is_scoped_enum","author":"admin","date":"August 13, 2023","format":false,"excerpt":"The type trait \"std::is_scoped_enum::value\" was introduced in C++23 to check whether the type \u201cT\u201d is a scoped enum type. Another way to use this is std::is_scoped_enum_v. Before getting into this trait in detail, let us briefly recap the differences between unscoped and scoped enums. Unscoped Enums Unscoped enums are the\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Unscoped Enums","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/08\/unscoped-300x110.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/08\/unscoped-300x110.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/08\/unscoped-300x110.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":1960,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/04\/12\/stdcommon_type-type-trait\/","url_meta":{"origin":666,"position":5},"title":"std::common_type Type Trait","author":"admin","date":"April 12, 2020","format":false,"excerpt":"In today's post, I would like to go over the type trait std::common_type<>. This trait was introduced in C++11. As per the specification, std::common_type::type refers to a type Tx in the given list, which the rest of the types in the list can be implicitly converted to. This\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Program Output","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/04\/Fig5.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/666","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/comments?post=666"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/666\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=666"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=666"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=666"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}