{"id":110901,"date":"2025-02-24T07:00:00","date_gmt":"2025-02-24T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=110901"},"modified":"2025-02-24T09:24:49","modified_gmt":"2025-02-24T17:24:49","slug":"20250224-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20250224-00\/?p=110901","title":{"rendered":"C++\/WinRT implementation inheritance: Notes on winrt::implements<\/CODE>, part 4"},"content":{"rendered":"

Last time, we figured out the rules for inheriting winrt::implements<\/code> in C++\/WinRT runtime class implementations<\/a>: You can use winrt::implements<\/code> in your class hierarchy, as long as you use single inheritance for the winrt::implements<\/code> part. You are not allowed to derive multiply from two different winrt::implements<\/code> base classes.<\/p>\n

One case of this is a base class that is configured at construction.<\/p>\n

struct StringableInt32 :\r\n    winrt::implements<StringableInt32,\r\n        winrt::Windows::Foundation::IStringable>\r\n{\r\n    StringableInt32(int value) : m_value(value) {}\r\n\r\n    winrt::hstring ToString()\r\n    { return winrt::to_hstring(m_value); }\r\n\r\nprivate:\r\n    int m_value;\r\n};\r\n<\/pre>\n
We can use this by itself:<\/p>\n
auto o = winrt::make<StringableInt32>(42);\r\n<\/pre>\n
But we can also tell the implements<\/code> template that we would like to derive from it.<\/p>\n
struct Derived :\r\n    winrt::implements<Derived, StringableInt32>\r\n{\r\n    Derived() : StringableInt32(42) {}\r\n};\r\n<\/pre>\n
Unfortunately, this doesn’t work because StringableInt32<\/code> is an indirect base class, and you can initialize only direct base classes in the constructor. So how do you initialize the StringableInt32<\/code>?<\/p>\n
The answer can be found by looking at the definition of winrt::implements<\/code>.<\/p>\n
template <typename D, typename... I>\r\nstruct implements :\r\n    impl::producers<D, I...>,\r\n    impl::base_implements<D, I...>::type\r\n{\r\nprotected:\r\n\r\n    using base_type = typename\r\n        impl::base_implements<D, I...>::type;\r\n    using root_implements_type = typename\r\n        base_type::root_implements_type;\r\n    using is_factory = typename\r\n        root_implements_type::is_factory;\r\n\r\n    using base_type::base_type;<\/span>\r\n<\/pre>\n
We saw last time that  base_implements<\/code> looks for the template parameter that is itself derived from implements<\/code><\/a>, and makes its type<\/code> member type be that template parameter. We define base_type<\/code> to be that type, which in our case is Stringable\u00adInt32<\/code>.<\/p>\n
The using base_type::base_type<\/code> imports the constructors of base_type<\/code> as constructors of implements<\/code>. And for us, this means that we can use the StringableInt32(int value)<\/code> constructor as if it were a constructor of implements<\/code>.<\/p>\n
struct Derived :\r\n    winrt::implements<Derived, StringableInt32>\r\n{\r\n    Derived() : implements<\/span>(42) {}\r\n};\r\n<\/pre>\n
The base class can expose other methods to the derived class in the usual way.<\/p>\n
struct StringableInt32 :\r\n    winrt::implements<StringableInt32,\r\n        winrt::Windows::Foundation::IStringable>\r\n{\r\n    StringableInt32(int value) : m_value(value) {}\r\n\r\n    winrt::hstring ToString()\r\n    { return winrt::to_hstring(m_value); }\r\n\r\n    void set_value(int value) { m_value = value; }<\/span>\r\n\r\nprivate:\r\n    int m_value;\r\n};<\/pre>\n
struct Derived :\r\n    winrt::implements<Derived, StringableInt32>\r\n{\r\n    Derived() : implements(42) {}\r\n\r\n    void Reset() { set_value(0); }<\/span>\r\n};\r\n<\/pre>\n
Okay, so this works for base classes that can fully implement an interface. But what if the base class wants to delegate part of its implementation to the derived class? We’ll look at that next time.<\/p>\n","protected":false},"excerpt":{"rendered":"
Simple inheritance of a self-contained implements<\/CODE>.<\/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-110901","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Simple inheritance of a self-contained implements<\/CODE>.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110901","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=110901"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110901\/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=110901"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=110901"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=110901"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}