{"id":700,"date":"2017-11-21T12:46:13","date_gmt":"2017-11-21T12:46:13","guid":{"rendered":"http:\/\/www.rangakrish.com\/?p=700"},"modified":"2017-11-21T13:30:02","modified_gmt":"2017-11-21T13:30:02","slug":"c17-stdoptional","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2017\/11\/21\/c17-stdoptional\/","title":{"rendered":"C++17: std::optional<>"},"content":{"rendered":"

Suppose we want to write a function that returns a value, but with the possibility that\u00a0 the computation might fail. This failure<\/strong><\/em> can be represented as an exception, or as a return value that unamibiguously denotes failure (for example, -1<\/strong><\/em>). Throwing an exception is a strong form of failure and might not be appropriate in certain situations. Take the example of a lookup table that maps strings to integers. If the given key is in the table, then we can return the corresponding integer value. But what if the string is not in the table? This could be a common scenario in the application domain, and hence throwing an exception is too costly, besides complicating the processing logic. On the other hand, we cannot return something like -1<\/strong><\/em> to indicate failure because the value associatd with the key could be an arbitrary integer! Of course, we can introduce an extra function argument to denote the status code, but this is not elegant. What we need in this situation is the ability to return a valid value, or to return something that denotes no value<\/strong><\/em>. std::optional<T><\/strong><\/em> proves handy in such situations.<\/p>\n

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

\"Example1\"<\/a>
Example1<\/strong><\/figcaption><\/figure>\n

Here we define an optional<\/strong><\/em> variable to hold integers<\/strong><\/em>. This means the variable can, at any time, contain an integer value, or no value at all. As you can see from the variable definition, because there is no initial value for this variable, it is deemed to contain no value<\/strong> <\/em>to start with.<\/p>\n

How can we find out if the variable contains a value or not? There is a member function called has_value()<\/strong><\/em> that returns true <\/i><\/b>if it has a value, or false <\/i><\/b>if it doesn’t. Or, because there is an implicit conversion to bool<\/strong><\/em>, we can directly use the variable in a conditional expression.<\/p>\n

As in the case of regular variables, we can assign a value to the optional variable and replace its current value, if any. So, in the above example, only the third conditional check prints the value.<\/p>\n

Can we use optional<\/strong><\/em> with user-defined types? Yes, of course. Let us consider a simple struct X<\/strong><\/em> shown in the following figure:<\/p>\n

\"User-defined<\/a>
User-defined Type<\/strong><\/figcaption><\/figure>\n

The code fragment below shows how this is used with optional<\/strong><\/em>.<\/p>\n

\"Example2\"<\/a>
Example2<\/strong><\/figcaption><\/figure>\n

As in the first example, because the optional variable is defined using default initialization, the variable is deemed to be empty. However, when we provide an explicit initial value for the variable opt_val2<\/strong><\/em>, the optional holds that value.<\/p>\n

The next example shows different ways to get the value of the optional variable. We can use the value()<\/strong><\/em> member function, use direct assignment, or use the smart pointer dereferencing mechanism.<\/p>\n

\"Example3\"<\/a>
Example3<\/strong><\/figcaption><\/figure>\n

Recall our initial discussion about a function returning a valid value or no value at all. To simplify the usage of such functions, there is a member function called value_or()<\/strong> <\/em>that allows us to supply a default value to use in case the function returns no value. This is illustratd in the following example:<\/p>\n

\"Example4\"<\/a>
Example4<\/strong><\/figcaption><\/figure>\n

Notice how the getValue(string)<\/i><\/b> function returns std::nullopt<\/strong><\/em> to denote no value. The next code fragment uses value_or()<\/strong><\/em> to return 9999<\/strong><\/em> if getValue() happens to return no value. This allows us to write much cleaner code.<\/p>\n

What if we want an optional variable that currently holds a value to become empty (i.e. no value)? The reset() <\/i><\/b>member function does just that. This function destroys<\/strong><\/em> the value in the optional (calls destructor for user defined types). This is shown in the example below:<\/p>\n

\"Example5\"<\/a>
Example5<\/strong><\/figcaption><\/figure>\n

Once reset, the optional has no value as the example illustrates.<\/p>\n

In summary, std::optional<><\/strong><\/em> gives us an elegant (and efficient) construct to represent the mutually exclusive value\/no value<\/strong><\/em> phenomenon.<\/p>\n

By the way, could we have used std::tuple<><\/strong><\/em>, std::pair<><\/strong><\/em>, or std::variant<><\/strong><\/em> to model this situation? Think about it. More on this in a future article!<\/p>\n

The example source code is here.<\/a> This has been tested in Visual Studio 2017.<\/p>\n

Have a wonderful day!<\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

Suppose we want to write a function that returns a value, but with the possibility that\u00a0 the computation might fail. This failure can be represented as an exception, or as a return value that unamibiguously denotes failure (for example, -1). Throwing an exception is a strong form of failure and might not be appropriate in […]<\/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_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},"jetpack_post_was_ever_published":false},"categories":[49,17],"tags":[118,122,123],"class_list":["post-700","post","type-post","status-publish","format-standard","hentry","category-c","category-programming","tag-c17","tag-stdoptional","tag-visual-studio-2017"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-bi","jetpack-related-posts":[{"id":3106,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/05\/13\/stdexpected\/","url_meta":{"origin":700,"position":0},"title":"std::expected","author":"admin","date":"May 13, 2023","format":false,"excerpt":"I had written about std::optional<> in an earlier article. C++23 introduces std::expected<> as an interesting extension to std::optional<>. Whereas std::optional<> contains a value or none at all, std::expected<> contains a value or an error code associated with it. This gives better control to the caller in terms of handling the\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"An Example","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/05\/source1-300x265.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/05\/source1-300x265.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/05\/source1-300x265.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":683,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/11\/05\/c17-stdvariant\/","url_meta":{"origin":700,"position":1},"title":"C++17: std::variant","author":"admin","date":"November 5, 2017","format":false,"excerpt":"C++17 introduces a new type-safe union in the form of std::variant. At any time, it can store a single value from one of many types. We need to include \u00a0to use this feature. Let us look at a simple example to get started: First, we define a variant object v1\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\/11\/Example1.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/11\/Example1.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/11\/Example1.png?resize=525%2C300 1.5x"},"classes":[]},{"id":717,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/12\/03\/c17-stdany\/","url_meta":{"origin":700,"position":2},"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":2280,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/01\/17\/c20-nodiscard-attribute\/","url_meta":{"origin":700,"position":3},"title":"C++20 [[nodiscard]] Attribute","author":"admin","date":"January 17, 2021","format":false,"excerpt":"[[nodiscard]]\u00a0attribute \u201cencourages\u201d the compiler to issue a warning when the return value from a function is ignored. It was introduced in C++ 17 and enhanced in C++ 20 to include a string literal that can be used as an explanation of the warning. Let us look at different cases one\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Case-1: Enumeration","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/01\/Example1-src-300x261.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/01\/Example1-src-300x261.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/01\/Example1-src-300x261.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":3184,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/08\/13\/stdis_scoped_enum\/","url_meta":{"origin":700,"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":198,"url":"https:\/\/www.rangakrish.com\/index.php\/2016\/04\/08\/c14-return-type-deduction-for-normal-functions\/","url_meta":{"origin":700,"position":5},"title":"C++14: Return Type Deduction for Normal Functions","author":"admin","date":"April 8, 2016","format":false,"excerpt":"In C++11, a function must specify its return type in one of the following two ways: int aFunction(int arg) { \u00a0 \u00a0 return arg * 2; } (or) auto aFunction(int arg) -> int { \u00a0 \u00a0 return arg * 2; } The first is the classic function definition syntax. The\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/700","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=700"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/700\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=700"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=700"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=700"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}