{"id":717,"date":"2017-12-03T08:31:23","date_gmt":"2017-12-03T08:31:23","guid":{"rendered":"http:\/\/www.rangakrish.com\/?p=717"},"modified":"2017-12-03T09:52:30","modified_gmt":"2017-12-03T09:52:30","slug":"c17-stdany","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2017\/12\/03\/c17-stdany\/","title":{"rendered":"C++17: std::any"},"content":{"rendered":"

In the previous two posts, I talked about std::variant<><\/i><\/b> and std::optional<><\/i><\/b>. Today, I want to take up std::any <\/i><\/b>for discussion.<\/p>\n

The type any <\/i><\/b>(implemented by the class any<\/i><\/b>) allows a variable to hold a single value of any type. More interestingly, the type of the value held by a variable of type any <\/i><\/b>can even change dynamically. In this sense, it is different from variant<> <\/i><\/b>and optional<><\/i><\/b>.<\/p>\n

We have to include the header <any> <\/i><\/b>in order to use this type.<\/i><\/p>\n

Let us start with a simple example and explore the various features of this type. Consider the following code snippet.<\/p>\n

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

Here we create two variables of any <\/i><\/b>type, one initialized with integer value and the other with a string. To retrieve the contained value of the variable, we need to use the templated any_cast<>() <\/i><\/b>function. This function can also be used to assign a new value to the variable, but of the same type as the existing value.<\/p>\n

It is OK to define a variable of any <\/i><\/b>type without initializing it; the value could be set later. We can use the member function has_value()<\/strong><\/em> to check if the variable has a value. See the following example.<\/p>\n

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

Notice how we can directly assign a value to the variable. We do not have to use any_cast<T>(v)<\/strong> <\/em>as we did in the earlier example.<\/p>\n

The next example given below shows how we can assign different value types to the same\u00a0any <\/i><\/b>type variable.<\/p>\n

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

It is important to remember that when we use any_cast<T>(v)<\/i><\/b>, we have to use the current value type.<\/p>\n

What happens if we use any_cast<T>(v) <\/i><\/b>to access a variable, but the type we specify is different from the current value type? This causes an exception of type bad_any_cast <\/i><\/b>to be thrown. See this code fragment:<\/p>\n

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

It is possible to destroy the value contained in an any <\/i><\/b>type variable using the reset()<\/strong><\/em> member function. Once reset, the variable holds no value. This is illustrated below.<\/p>\n

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

So far, we have shown the any <\/i><\/b>type variable being used with primitive value types such as integer. Can the type hold values of user-defined types? Yes, of course. Here is how:<\/p>\n

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

There is one requirement when we use user-defined types with any<\/i><\/b>. And that is, the user-defined type must be copy constructible<\/i><\/b>. In other words, it must have a copy constructor<\/strong><\/em>. In the example below, struct Y <\/i><\/b>has a deleted <\/i><\/b>copy constructor, and hence it cannot be used with any <\/i><\/b>type.<\/p>\n

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

Here is another cool thing. Normally collections such as arrays and vectors require that the contained elements belong to the same type. Of course, we can use inheritance and pointers to store objects belonging to the same hierarchy. But when you create an array or vector of any<\/strong><\/em> type, you can actually store objects of unrelated types! This is illustrated in the following example.<\/p>\n

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

Notice how we can use the type() <\/i><\/b>member function of any <\/i><\/b>to get the type description of the contained object.<\/p>\n

As the last point to discuss, let us see if there is any space overhead in using any <\/i><\/b>type. The following code fragment uses the sizeof()<\/i><\/b> operator to print the number of bytes allocated to many objects of any <\/i><\/b>type, each holding a different value type.<\/p>\n

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

What is surprising is that each of the variables, irrespective of the respective value type, seems to have been allocated 40 bytes! Even if the variable is uninitialized, this is indeed the case.<\/p>\n

Given the flexibility that any <\/i><\/b>gives us in storing any value type, and even changing it dynamically, we are prepared for additional overhead, but why this much (constant value)? I am certain this is implementation dependent.<\/p>\n

That is std::any<\/strong><\/em> for you. Hope you found the discussion interesting. The example source is available\u00a0here<\/a>. I tested this on VS 2017.<\/p>\n

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

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 of type any can even […]<\/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,124],"class_list":["post-717","post","type-post","status-publish","format-standard","hentry","category-c","category-programming","tag-c17","tag-stdany"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-bz","jetpack-related-posts":[{"id":700,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/11\/21\/c17-stdoptional\/","url_meta":{"origin":717,"position":0},"title":"C++17: std::optional","author":"admin","date":"November 21, 2017","format":false,"excerpt":"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\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-3.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/11\/Example1-3.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/11\/Example1-3.png?resize=525%2C300 1.5x"},"classes":[]},{"id":683,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/11\/05\/c17-stdvariant\/","url_meta":{"origin":717,"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":3106,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/05\/13\/stdexpected\/","url_meta":{"origin":717,"position":2},"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":1973,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/04\/26\/stdis_base_of\/","url_meta":{"origin":717,"position":3},"title":"std::is_base_of","author":"admin","date":"April 26, 2020","format":false,"excerpt":"In our on-going series on C++ Type Traits, today's topic is about the trait std::is_base_of<>. For the official description, see this. std::is_base_of::value takes two arguments, both classes (or structs), and returns true if A is a base class of B and false otherwise. Trivially, std::::value is true. Let\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Output","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/04\/Output.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":1928,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/03\/15\/stdis_destructible\/","url_meta":{"origin":717,"position":4},"title":"std::is_destructible","author":"admin","date":"March 15, 2020","format":false,"excerpt":"In the last article, I explained the deleted destructor in some detail. Today, I would like to talk about a related construct, a type trait called std::is_destructible. Type traits, defined in the header , are a big help when it comes to implementing template metaprogramming. \u00a0See this\u00a0article for a nice\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Private\/Protected Destructor","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example7.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example7.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example7.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":717,"position":5},"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":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/717","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=717"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/717\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=717"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=717"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=717"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}