{"id":102678,"date":"2019-07-10T07:00:00","date_gmt":"2019-07-10T14:00:00","guid":{"rendered":"http:\/\/devblogs.microsoft.com\/oldnewthing\/?p=102678"},"modified":"2019-07-10T23:15:12","modified_gmt":"2019-07-11T06:15:12","slug":"20190710-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20190710-00\/?p=102678","title":{"rendered":"Detecting in C++ whether a type is defined, part 3: SFINAE and incomplete types"},"content":{"rendered":"

Warning to those who got here via a search engine<\/b>: This is part of a series. Keep reading to the end.<\/p>\n

For the past few articles, I’ve been playing with the unqualified name lookup<\/a> search order in order to detect whether a type exists in a particular namespace. I did this by defining the type in another namespace that has lower priority than the namespace that I’m probing, and then seeing which type comes out when I access the type with an unqualified name.<\/p>\n

There are many problems with this technique. One is that it requires you to set up a detect<\/code> namespace that contains a shadow version of every type you want to check. Another is that you need to inject a detect<\/code> sub-namespace into every namespace you want to do detection in.<\/p>\n

But it turns out there’s another way, as long as you’re willing to change one of the requirements. Instead of checking whether the type exists, check whether the type is defined<\/i>, which in C++ language standard jargon means that you want the type to be complete<\/a>.<\/p>\n

template<typename, typename = void>\r\nconstexpr bool is_type_complete_v = false;\r\n\r\ntemplate<typename T>\r\nconstexpr bool is_type_complete_v\r\n    <T, std::void_t<decltype(sizeof(T))>> = true;\r\n<\/pre>\n
A type must be complete in order to have the sizeof<\/code> operator applied to it, so we use  SFINAE<\/a> to define is_<\/code>type_<\/code>complete_v<\/code> as true<\/code> provided the sizeof<\/code> operator can be applied.\u00b9<\/p>\n
I’m not sure if this is technically legal, but all the compilers I tried seemed to be okay with it. It does lead to weird effects like this:<\/p>\n
struct s; \/\/ incomplete type\r\nbool val1 = is_type_complete_v<s>; \/\/ false\r\nstruct s {}; \/\/ now it's complete\r\nbool val2 = is_type_complete_v<s>; \/\/ true\r\n<\/pre>\n
The second phase of the trick takes advantage of the fact that you are permitted to refer to a class with the struct<\/code> or class<\/code> prefix. This prefix is usually redundant,  but not always<\/a>. It’s also how you declare a forward reference.<\/p>\n
The result is that you can say<\/p>\n
is_type_complete_v<struct special>\r\n<\/pre>\n
to determine whether struct special<\/code> has been defined.<\/p>\n
    \n
  1. If it has been defined, then the type exists and is complete.<\/li>\n
  2. If it has been declared but not defined, then the type exists and is incomplete.<\/li>\n
  3. If it has been neither declared nor defined, the act of writing struct special<\/code> serves as a declaration! This puts us back into case 2 above, and the type exists and is incomplete.<\/li>\n<\/ol>\n
    So now our helper can be simplified to<\/p>\n
    template<typename T, typename TLambda>\r\nvoid call_if_defined(TLambda&& lambda)\r\n{\r\n  if constexpr (is_complete_type_v<T>) {\r\n    lambda(static_cast<T*>(nullptr));\r\n  }\r\n}\r\n<\/pre>\n
    and you would use it like this:<\/p>\n
    void foo(Source source)\r\n{\r\n  call_if_defined<struct special>([&](auto* p)\r\n  {\r\n    using special = std::decay_t<decltype(*p)>;\r\n    special::static_method();\r\n    auto s = source.try_get<special>();\r\n    if (s) s->something();\r\n  });\r\n}\r\n<\/pre>\n
    We are using the same tricks that we introduced last time: Using a generic lambda to defer resolving the type until the lambda is invoked, using if constexpr<\/code> to avoid invoking the lambda if the type is not defined, and reintroducing the name of the type by deriving it from the dummy parameter.<\/p>\n
    There is a catch here: If you are probing for a type that is defined in a namespace that you imported via a using<\/code> directive, and the type does not actually exist, then the struct special<\/code> will declare an incomplete struct special<\/code> in the current<\/i> namespace.<\/p>\n
    \/\/ awesome.h\r\nnamespace awesome\r\n{\r\n  \/\/ might or might not contain\r\n  struct special { ... };\r\n}\r\n\r\n\/\/ your code\r\nnamespace app\r\n{\r\n  using namespace awesome;\r\n\r\n  void foo()\r\n  {\r\n    call_if_defined<struct special>([&](auto* p)\r\n    {\r\n       ...\r\n    });\r\n  }\r\n}\r\n<\/pre>\n
    If special<\/code> is not defined, then the struct special<\/code> in the call_<\/code>if_<\/code>defined<\/code> will introduce an incomplete type called app::<\/code>special<\/code>.<\/p>\n
    Even more frustrating is that you cannot do this:<\/p>\n
    namespace app\r\n{\r\n  void foo()\r\n  {\r\n    call_if_defined<struct awesome::special<\/span>>([&](auto* p)\r\n    {\r\n       ...\r\n    });\r\n  }\r\n}\r\n<\/pre>\n
    You cannot forward-declare a type into a non-current namespace. (For one thing, the result is ambiguous: Is this trying to forward-declare ::awesome<\/code>::special<\/code>, or is it trying to forward-declare ::app<\/code>::awesome<\/code>::special<\/code>?)<\/p>\n
    And of course there’s the annoyance of having to type the word struct<\/code>.<\/p>\n
    We can trade three annoyances for one. We’ll continue the investigation next time.<\/p>\n
    \u00b9 The std::<\/code>void_t<\/code> template type is void<\/code> regardless of its template parameters. The template type exists specifically for SFINAE, so that the overload is removed from consideration if the template parameter ends up being invalid. In this case, what it means is that if sizeof(T)<\/code> is invalid (which is the case if T<\/code> is an incomplete type), then the std::<\/code>void_t<\/code> fails substitution, and the rule disappears.<\/p>\n
    You can think of it as std::<\/code>void_<\/code>if_<\/code>valid_t<\/code>.<\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    You can give something a name without saying what it is.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-102678","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
    You can give something a name without saying what it is.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/102678","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=102678"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/102678\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=102678"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=102678"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=102678"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}