{"id":1928,"date":"2020-03-15T11:08:41","date_gmt":"2020-03-15T05:38:41","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=1928"},"modified":"2020-03-15T11:11:34","modified_gmt":"2020-03-15T05:41:34","slug":"stdis_destructible","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2020\/03\/15\/stdis_destructible\/","title":{"rendered":"std::is_destructible"},"content":{"rendered":"

In the last article<\/strong><\/em><\/a>, I explained the deleted destructor<\/strong><\/em> in some detail. Today, I would like to talk about a related construct, a type trait<\/strong><\/em> called std::is_destructible<\/strong><\/em>.<\/p>\n

Type traits, defined in the header <type_traits><\/strong><\/em>, are a big help when it comes to implementing template metaprogramming<\/strong><\/em>. \u00a0<\/span>See this<\/strong><\/em><\/a>\u00a0article for a nice introduction to type traits in C++.<\/p>\n

The std::is_destructible<\/strong><\/em><\/a> trait checks whether objects of the given type T<\/strong><\/em> can be destroyed<\/strong><\/em>. What does this mean? Let us go through some examples.<\/p>\n

\"Some<\/a>
Some structs<\/strong><\/figcaption><\/figure>\n

\u00a0<\/span>The above defines several structs<\/strong><\/em>. Here is the main<\/strong><\/em>\u00a0function that applies std::is_destructible<T><\/strong><\/em> on the above structs.\u00a0<\/span><\/p>\n

\"Applying<\/a>
Applying std::is_destructible<\/strong><\/figcaption><\/figure>\n

All these types have either the default or an explicit destructor, and hence objects of these types can be destroyed in the normal way. So, as expected, the program prints true<\/strong><\/em> for all of them.<\/p>\n

Note that we do not have to create objects of these types in order to check if\u00a0 <\/span>they are destructible.<\/p>\n

Some of you may be wondering if std::is_destructible<\/strong><\/em> depends on compile time<\/strong><\/em> or run time<\/strong><\/em> check. The answer is that this is purely a compile time<\/em><\/strong> check! Isn’t that interesting? Look at the modified main<\/strong><\/em> below:<\/p>\n

\"Compile<\/a>
Compile Time Check<\/strong><\/figcaption><\/figure>\n

The above code compiles without any error, but does not print anything at run time. You can read about static_assert<\/strong><\/em><\/a> here.<\/p>\n

OK. Let us now consider some examples where the destructor<\/strong><\/em> has been deleted<\/strong><\/em>.<\/p>\n

\"Deleted<\/a>
Deleted Destructor<\/strong><\/figcaption><\/figure>\n

In all the above cases, objects of these types cannot be destroyed.\u00a0If you recall our discussion on deleted destructors in the earlier article<\/strong><\/em><\/a>, you will agree that the above behaviour is as expected.<\/p>\n

Can we apply std::is_destructible<\/strong><\/em> to primitive types? Of course. See below:<\/p>\n

\"Primitive<\/a>
Primitive Types<\/strong><\/figcaption><\/figure>\n

Notice that the output is true<\/strong><\/em> in all except the last two cases.<\/p>\n

Although it is not directly relevant, let us also consider the case of a destructor<\/strong><\/em> being private<\/strong><\/em> or protected<\/strong><\/em>. The following code fragment shows what happens in these cases.<\/p>\n

\"Private\/Protected<\/a>
Private\/Protected Destructor<\/strong><\/figcaption><\/figure>\n

Although X<\/strong><\/em> destructor is accessible from within X::foo()<\/strong><\/em>, is_destructible<X><\/strong><\/em> returns false<\/strong><\/em>!<\/p>\n

std::is_trivially_destructible<\/h2>\n

This is a variant of std::is_destructible<\/strong><\/em>. See this page<\/strong><\/em><\/a> for the official specification. Here are some examples:<\/p>\n

\"std::is_trivially_destructible\"<\/a>
std::is_trivially_destructible<\/strong><\/figcaption><\/figure>\n

Hope you understand why line 27<\/strong><\/em> generates false<\/strong><\/em>. The class Z<\/strong><\/em> has a deleted destructor and so it cannot be destroyed. So, if std::is_destructible<\/strong><\/em> is false, then so is std::is_trivially_destructible<\/strong><\/em>.<\/p>\n

std::is_nothrow_destructible<\/h2>\n

This is yet another variant. It checks if the underlying T<\/strong><\/em> is destructible, and in addition, if the destructor is present, whether it is declared noexcept(true)<\/strong><\/em>.\u00a0<\/span><\/p>\n

Here are some examples:<\/p>\n

\"std::is_nothrow_destructible\"<\/a>
std::is_nothrow_destructible<\/strong><\/figcaption><\/figure>\n

By default, a destructor is noexcept<\/strong><\/em>.<\/p>\n

Well, that is it for today. Hope I managed to convey the essence of the traits std::is_destructible<\/strong><\/em>, std::is_trivially_destructible<\/strong><\/em> and std::is_nothrow_destructible<\/strong><\/em>.<\/p>\n

You can download the source files from here<\/strong><\/em><\/a>. I used Visual Studio 2019 ver 16.4.5<\/strong><\/em> to test the examples.<\/p>\n

Have a nice weekend!<\/p>\n","protected":false},"excerpt":{"rendered":"

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 <type_traits>, are a big help when it comes to implementing template metaprogramming. \u00a0See this\u00a0article for a nice introduction to type traits 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_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":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[49,17],"tags":[67,231,233,232],"class_list":["post-1928","post","type-post","status-publish","format-standard","hentry","category-c","category-programming","tag-c","tag-stdis_destructible","tag-stdis_nothrow_destructible","tag-stdis_trivially_destructible"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-v6","jetpack-related-posts":[{"id":1973,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/04\/26\/stdis_base_of\/","url_meta":{"origin":1928,"position":0},"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":1946,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/03\/28\/stdis_empty\/","url_meta":{"origin":1928,"position":1},"title":"std::is_empty","author":"admin","date":"March 28, 2020","format":false,"excerpt":"In the previous post, we looked at the std::is_destructible type trait. Today, let us try to understand another type trait std::is_empty. As per the specification, is_empty::value will return true in the following cases: - The class\/struct has no non-static data member - The class\/struct does not define a virtual function\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Example4: Union and Bit Field","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example4-1.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example4-1.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/03\/Example4-1.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":1928,"position":2},"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":683,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/11\/05\/c17-stdvariant\/","url_meta":{"origin":1928,"position":3},"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":2889,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/08\/09\/stdarray-vs-stdvector\/","url_meta":{"origin":1928,"position":4},"title":"std::array vs. std::vector","author":"admin","date":"August 9, 2022","format":false,"excerpt":"One of the common questions when starting to study the container abstractions in C++20 is \"Should I use std::array\u00a0or std::vector?\". The correct answer is \"use what is best suited for the current situation\". That is not good enough, obviously. In this short article, I will try to answer this question\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"std::array Example","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/08\/code1-300x150.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/08\/code1-300x150.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/08\/code1-300x150.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":1928,"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\/1928","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=1928"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/1928\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=1928"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=1928"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=1928"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}