{"id":25034,"date":"2019-10-01T14:52:46","date_gmt":"2019-10-01T14:52:46","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=25034"},"modified":"2019-10-01T14:52:46","modified_gmt":"2019-10-01T14:52:46","slug":"c20s-conditionally-explicit-constructors","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/c20s-conditionally-explicit-constructors\/","title":{"rendered":"C++20’s Conditionally Explicit Constructors"},"content":{"rendered":"

explicit(bool)<\/code> is a C++20 feature for simplifying the implementation of generic types and improving compile-time performance.<\/p>\n

In C++ it is common to write and use types which wrap objects of other types. std::pair<\/code> and std::optional<\/code> are two examples, but there are plenty of others in the standard library, Boost, and likely your own codebases. Following the principle of least astonishment<\/a>, it pays to ensure that these wrappers preserve the behavior of their stored types as much as is reasonable.<\/p>\n

Take std::string<\/code> as an example. It allows implicit conversion from a string literal, but not<\/em> from a std::string_view<\/code>:<\/p>\n

void f(std::string);\r\n\r\nf(\u201chello\u201d);   \/\/compiles\r\nf(\u201chello\u201dsv); \/\/compiler error<\/pre>\n
This is achieved in std::string<\/code> by marking the constructor which takes a std::string_view<\/code> as explicit<\/a>.<\/p>\n
If we are writing a wrapper type, then in many cases we would want to expose the same behaviour, i.e. if the stored type allows implicit conversions, then so does our wrapper; if the stored type does not, then our wrapper follows[1]<\/a><\/sup>. More concretely:<\/p>\n
void g(wrapper<std::string>);\r\n\r\ng(\"hello\");   \/\/this should compile\r\ng(\"hello\"sv); \/\/this should not<\/pre>\n
The common way to implement this is using SFINAE. If we have a wrapper which looks like this[2]<\/a><\/sup>:<\/p>\n
template<class T>\r\nstruct wrapper {\r\n  template <class U>\r\n  wrapper(U const& u) : t_(u) {}\r\n\r\n  T t_;\r\n};<\/pre>\n
Then we replace the single constructor with two overloads: one implicit constructor for when U<\/code> is convertible to T<\/code> and one explicit overload for when it is not:<\/p>\n
template<class T>\r\nstruct wrapper {\r\n  template<class U, std::enable_if_t<std::is_convertible_v<U, T>>* = nullptr>\r\n  wrapper(U const& u) : t_(u) {}\r\n  \r\n  template<class U, std::enable_if_t<!std::is_convertible_v<U, T>>* = nullptr>\r\n  explicit wrapper(U const& u) : t_(u) {}\r\n\r\n  T t_;\r\n};<\/pre>\n
This gives our type the desired behavior. However, it\u2019s not very satisfactory: we now need two overloads for what should really be one and we\u2019re using SFINAE to choose between them, which means we take hits on compile-time and code clarity.explicit(bool)<\/code> solves both problems by allowing you to lift the convertibility condition into the explicit<\/code> specifier:<\/p>\n
template<class T> \r\nstruct wrapper { \r\n  template<class U> \r\n  explicit(!std::is_convertible_v<U, T>) \r\n  wrapper(U const& u) : t_(u) {} \r\n\r\n  T t_; \r\n};<\/pre>\n
Next time you need to make something conditionally explicit, use explicit(bool)<\/code> for simpler code, faster compile times[3]<\/a><\/sup>, and less code repetition.<\/p>\n
explicit(bool)<\/code> will be supported in MSVC v14.24[4]<\/a><\/sup> (available in Visual Studio 2019 version 16.4), Clang 9, and GCC 9. We\u2019d love for you to download Visual Studio 2019<\/a> and give it a try. As always, we welcome your feedback. We can be reached via the comments below or via email (visualcpp@microsoft.com<\/a>). If you encounter problems with Visual Studio or MSVC, or have a suggestion for us, please let us know through Help > Send Feedback > Report A Problem \/ Provide a Suggestion<\/strong> in the product, or via Developer Community<\/a>. You can also find us on Twitter (@VisualC<\/a>).<\/p>\n
    \n
  1. I know, implicit conversions are evil. There are some places where they make a big improvement to ergonomics though and leaving choices to users makes our generic types more widely applicable. \u2191<\/a><\/li>\n
  2. std::forward<\/code> and such omitted for brevity. \u2191<\/a><\/li>\n
  3. I tested 500 template instantiations with Visual Studio 2019 version 16.2 and using explicit(bool)<\/code> sped up the frontend by ~15% \u2191<\/a><\/li>\n
  4. The feature is supported in MSVC v14.22 (Visual Studio 2019 version 16.2) for builds with \/permissive-, but there are some issues for builds which do not use that flag. \u2191<\/a><\/li>\n<\/ol>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    explicit(bool) is a C++20 feature for simplifying the implementation of generic types and improving compile-time performance. In C++ it is common to write and use types which wrap objects of other types. std::pair and std::optional are two examples, but there are plenty of others in the standard library, Boost, and likely your own codebases. Following […]<\/p>\n","protected":false},"author":706,"featured_media":25040,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[512],"tags":[],"class_list":["post-25034","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-general-cpp-series"],"acf":[],"blog_post_summary":"
    explicit(bool) is a C++20 feature for simplifying the implementation of generic types and improving compile-time performance. In C++ it is common to write and use types which wrap objects of other types. std::pair and std::optional are two examples, but there are plenty of others in the standard library, Boost, and likely your own codebases. Following […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/25034","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/users\/706"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/comments?post=25034"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/posts\/25034\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media\/25040"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/media?parent=25034"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/categories?post=25034"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cppblog\/wp-json\/wp\/v2\/tags?post=25034"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}