{"id":1960,"date":"2020-04-12T10:25:41","date_gmt":"2020-04-12T04:55:41","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=1960"},"modified":"2020-04-13T05:05:16","modified_gmt":"2020-04-12T23:35:16","slug":"stdcommon_type-type-trait","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2020\/04\/12\/stdcommon_type-type-trait\/","title":{"rendered":"std::common_type<> Type Trait"},"content":{"rendered":"

In today’s post, I would like to go over the type trait std::common_type<><\/strong><\/em><\/a>. This trait was introduced in C++11<\/strong><\/em>.<\/p>\n

As per the specification, std::common_type<T1, T2, …Tn>::type<\/strong><\/em> refers to a type Tx<\/strong><\/em> in the given list, which the rest of the types in the list can be implicitly converted to. This works with built-in as well as user-defined types.<\/p>\n

In the examples below, I will be using the Helper<\/strong><\/em> type:<\/p>\n

template< class… T ><\/strong><\/span><\/p>\n

using common_type_t = typename common_type<T…>::type;<\/strong><\/span><\/p>\n

This helper was introduced in C++14<\/strong><\/em>.<\/p>\n

Our first example demonstrates how this type trait works with built-in types:<\/p>\n

\"Common_type<\/a>
Common_type Trait with Built-in Types<\/strong><\/figcaption><\/figure>\n

Line 13<\/strong><\/em> defines a variable var1<\/strong><\/em>, whose type will be the common type of the three types “int”, “float” <\/strong><\/em>and “double”<\/strong><\/em>. As you might have guessed correctly, the common type happens to be “double”<\/strong><\/em>. This is verified in Line 14<\/strong><\/em>, where we print the name of the type (please note that the exact name printed is compiler specific, but it should uniquely denote the type). The actual output is given in the following figure:<\/p>\n

\"Program<\/a>
Program Output<\/strong><\/figcaption><\/figure>\n

What about var2<\/strong><\/em> in Line 16<\/strong><\/em>? Since a “char”<\/strong><\/em> can be implicitly converted to an “int”<\/strong><\/em>, but not vice versa, “int”<\/strong><\/em> happens to be the common type here.<\/p>\n

We have a problem with var3<\/strong><\/em> in Line 19<\/strong><\/em>. There is no implicit conversion between “const char *”<\/strong><\/em> and either “int”<\/strong><\/em> or “char”<\/strong><\/em>. Hence this is a compile-time error.<\/p>\n

var4<\/strong><\/em> on Line 22<\/strong><\/em> will have the type “string”<\/strong><\/em> since “char *”<\/strong><\/em> can be implicitly converted to “string”<\/strong><\/em>.<\/p>\n

var5<\/strong><\/em> on Line 25<\/strong><\/em> illustrates another trivial case since “void”<\/strong><\/em> is incompatible with any other type.<\/p>\n

A slight variation of the above is var6<\/strong><\/em>. In this case, since pointer to any given type (except pointer to members) can be implicitly converted to “void *”<\/strong>, the type of var6<\/strong><\/em> will be “void *”<\/strong><\/em> and the output confirms this.<\/p>\n

Let us now consider some user-defined types. See the figure below.<\/p>\n

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

There is nothing complex here. The “<\/strong>Root”<\/strong><\/em> class serves as the base class for all the other classes. Classes “A”<\/strong><\/em> and “B”<\/strong><\/em> derive virtually from “Root”<\/strong><\/em> and because of this, class “E”<\/strong><\/em> (Line 29<\/strong><\/em>) gets a single instance of “Root”<\/strong><\/em> via both “A”<\/strong><\/em> and “B”<\/strong><\/em>.<\/p>\n

Here is the code fragment showing the usage of common_type<><\/strong><\/em> in the context of this class hierarchy.<\/p>\n

\"Example<\/a>
Example Code<\/strong><\/em><\/figcaption><\/figure>\n

In Line 35<\/strong><\/em>, we define variables to hold the different user types.\u00a0<\/span><\/p>\n

Line 38<\/strong><\/em> defines a convenient lambda<\/strong><\/em> function to print the name of the class corresponding to a given object.<\/p>\n

Line 44<\/strong><\/em>: Since “C”<\/strong><\/em> is derived from “A”<\/strong><\/em>, “A”<\/strong><\/em> will be the common type<\/strong><\/em> here. Hence we can reference objects of type both “A”<\/strong><\/em> and “C”<\/strong><\/em> using this type.\u00a0<\/span><\/p>\n

The output from the sample program is here:<\/p>\n

\"Program<\/a>
Program Output<\/strong><\/figcaption><\/figure>\n

Line 48<\/strong><\/em>: “Root”<\/strong><\/em> is the virtual base class of “C”<\/strong><\/em> through “A”<\/strong><\/em>. Hence that is also the common type in this case.<\/p>\n

Line 52<\/strong><\/em>: Since “B”<\/strong><\/em> is a direct base class of “E”<\/strong><\/em>, the common type here will be “B”<\/strong><\/em>.<\/p>\n

Line 56<\/strong><\/em>: There should be no surprise here. “Root”<\/strong><\/em> is the common type.<\/p>\n

Line 64<\/strong><\/em> uses only one type, which is permitted. The common type is, trivially, that single type\u00a0“D”<\/strong><\/em>.<\/p>\n

Lines 69, 70 <\/strong><\/em>and 71<\/strong><\/em> show an important property of common_type<\/strong><\/em> trait. Although the pairs <A, B>, <C, D> <\/strong><\/em>and <D, E><\/strong><\/em> all share a common base class “Root”<\/strong><\/em>, that type is not identified as the common type through inference<\/strong><\/em>. The type trait only determines a common type, if possible, from among the listed types. This could come as a surprise to a few (it did to me initially!), but that is the reality.<\/p>\n

Hope today’s discussion throws sufficient clarity on this type trait. You can download the example code from here.<\/strong><\/em><\/a><\/p>\n

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

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<T1, T2, …Tn>::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 works with built-in as well […]<\/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,236,235],"class_list":["post-1960","post","type-post","status-publish","format-standard","hentry","category-c","category-programming","tag-c","tag-common_type","tag-type-trait"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-vC","jetpack-related-posts":[{"id":3184,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/08\/13\/stdis_scoped_enum\/","url_meta":{"origin":1960,"position":0},"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":1973,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/04\/26\/stdis_base_of\/","url_meta":{"origin":1960,"position":1},"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":2011,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/06\/06\/stdis_trivial\/","url_meta":{"origin":1960,"position":2},"title":"std::is_trivial","author":"admin","date":"June 6, 2020","format":false,"excerpt":"Today let us try to understand the type trait std::is_trivial. This trait checks if the given type is a trivial type. For a precise definition of what trivial means, please visit the official page. As usual, we will go through three cases: - Primitive types - Classes without inheritance -\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\/06\/output2.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":1960,"position":3},"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":2024,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/06\/21\/stdis_standard_layout\/","url_meta":{"origin":1960,"position":4},"title":"std::is_standard_layout","author":"admin","date":"June 21, 2020","format":false,"excerpt":"In our last post, we learnt about the type trait std::is_trivial. Today, let us go through another type trait that is quite similar. The expression\u00a0is_standard_layout::value returns true if the layout of objects of type T is compiler independent, and hence is of standard format. Else, it returns false. This is\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"The Difference","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/06\/Example4.jpg?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":1946,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/03\/28\/stdis_empty\/","url_meta":{"origin":1960,"position":5},"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":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/1960","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=1960"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/1960\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=1960"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=1960"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=1960"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}