{"id":107443,"date":"2022-11-23T07:00:00","date_gmt":"2022-11-23T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=107443"},"modified":"2024-01-02T21:03:59","modified_gmt":"2024-01-03T05:03:59","slug":"20221123-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20221123-00\/?p=107443","title":{"rendered":"Sometimes perfect forwarding can be too perfect: Lazy conversion is lazy"},"content":{"rendered":"

C++11 introduced the concept of perfect forwarding<\/i>, which uses universal references<\/i><\/span> forwarding references<\/i> to capture the value category of a passed-in parameter, so that it can be passed to another function as the same kind of reference.<\/p>\n

Forwarding references are used in many places, but the trap I’m looking at today is when the forwarding reference causes a conversion to be delayed to a point where it is no longer possible.<\/p>\n

class Base\r\n{\r\n    \/* ... *\/\r\n};\r\n\r\nclass BaseAcceptor\r\n{\r\npublic:\r\n    BaseAcceptor(Base* base);\r\n    \/* ... *\/\r\n};\r\n\r\nclass Derived : Base\r\n{\r\n    void DoSomething()\r\n    {\r\n        auto p1 = std::unique_ptr<BaseAcceptor>(new BaseAcceptor(this));\r\n        auto p2 = std::shared_ptr<BaseAcceptor>(new BaseAcceptor(this));\r\n\r\n        std::vector<BaseAcceptor> v;\r\n        v.push_back(BaseAcceptor(this));\r\n    }\r\n\r\n    \/* ... *\/\r\n};\r\n<\/pre>\n
But then you realize that you should be using the make_<\/code> functions, so that you can  avoid having to write the new<\/code> keyword<\/a>, and you can use the emplace<\/code> alternative to construct the vector element in place.<\/p>\n
class Derived : Base\r\n{\r\n    void DoSomething()\r\n    {\r\n        auto p1 = std::make_unique<BaseAcceptor>(this);\r\n        auto p2 = std::make_shared<BaseAcceptor>(this);\r\n\r\n        std::vector<BaseAcceptor> v;\r\n        v.emplace_back(this);\r\n    }\r\n};\r\n<\/pre>\n
And then everything explodes into tiny little pieces.<\/p>\n
\/\/ clang\r\n\r\nIn file included from memory:76:\r\nunique_ptr.h:1072:38: error: cannot cast 'Derived' to its private base class 'Base'\r\n    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }\r\n                                     ^\r\ntest.cpp:19:24: note: in instantiation of function template specialization 'std::make_unique<BaseAcceptor, Derived *>' requested here\r\n        auto p1 = std::make_unique<BaseAcceptor>(this);\r\n                       ^\r\ntest.cpp:14:17: note: implicitly declared private here\r\nclass Derived : Base\r\n                ^~~~\r\n\r\nIn file included from vector:62:\r\nstl_construct.h:119:29: error: cannot cast 'Derived' to its private base class 'Base'\r\n      ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);\r\n                            ^\r\nalloc_traits.h:635:9: note: in instantiation of function template specialization 'std::_Construct<BaseAcceptor, Derived *>' requested here\r\n        { std::_Construct(__p, std::forward<_Args>(__args)...); }\r\n               ^\r\nshared_ptr_base.h:604:30: note: in instantiation of function template specialization 'std::allocator_traits<std::allocator<void>>::construct<BaseAcceptor, Derived *>' requested here\r\n          allocator_traits<_Alloc>::construct(__a, _M_ptr(),\r\n                                    ^\r\nshared_ptr_base.h:972:6: note: in instantiation of function template specialization 'std::_Sp_counted_ptr_inplace<BaseAcceptor, std::allocator<void>, __gnu_cxx::_S_atomic>::_Sp_counted_ptr_inplace<Derived *>' requested here\r\n            _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);\r\n            ^\r\nshared_ptr_base.h:1712:14: note: in instantiation of function template specialization 'std::__shared_count<__gnu_cxx::_S_atomic>::__shared_count<BaseAcceptor, std::allocator<void>, Derived *>' requested here\r\n        : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)\r\n                    ^\r\nshared_ptr.h:464:4: note: in instantiation of function template specialization 'std::__shared_ptr<BaseAcceptor, __gnu_cxx::_S_atomic>::__shared_ptr<std::allocator<void>, Derived *>' requested here\r\n        : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)\r\n          ^\r\nshared_ptr.h:1009:14: note: in instantiation of function template specialization 'std::shared_ptr<BaseAcceptor>::shared_ptr<std::allocator<void>, Derived *>' requested here\r\n      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},\r\n             ^\r\ntest.cpp:20:24: note: in instantiation of function template specialization 'std::make_shared<BaseAcceptor, Derived *>' requested here\r\n        auto p2 = std::make_shared<BaseAcceptor>(this);\r\n                       ^\r\ntest.cpp:14:17: note: implicitly declared private here\r\nclass Derived : Base\r\n                ^~~~\r\n\r\nIn file included from vector:61:\r\nIn file included from allocator.h:46:\r\nIn file included from c++allocator.h:33:\r\nnew_allocator.h:182:27: error: cannot cast 'Derived' to its private base class 'Base'\r\n        { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }\r\n                                 ^\r\nalloc_traits.h:516:8: note: in instantiation of function template specialization 'std::__new_allocator<BaseAcceptor>::construct<BaseAcceptor, Derived *>' requested here\r\n          __a.construct(__p, std::forward<_Args>(__args)...);\r\n              ^\r\nvector.tcc:117:21: note: in instantiation of function template specialization 'std::allocator_traits<std::allocator<BaseAcceptor>>::construct<BaseAcceptor, Derived *>' requested here\r\n            _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,\r\n                           ^\r\ntest.cpp:23:11: note: in instantiation of function template specialization 'std::vector<BaseAcceptor>::emplace_back<Derived *>' requested here\r\n        v.emplace_back(this);\r\n          ^\r\ntest.cpp:14:17: note: implicitly declared private here\r\nclass Derived : Base\r\n                ^~~~\r\n\r\n\/\/ gcc\r\nIn file included from memory:76,\r\n                 from test.cpp:2:\r\ntest.cpp std::make_unique(_Args&& ...) [with _Tp = BaseAcceptor; _Args = {Derived*}; __detail::__unique_ptr_t<_Tp> = __detail::__unique_ptr_t<BaseAcceptor>]':\r\ntest.cpp:19:49:   required from here\r\nunique_ptr.h:1072:30: error: 'Base' is an inaccessible base of 'Derived'\r\n 1072 |     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }\r\n      |                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\nIn file included from c++allocator.h:33,\r\n                 from allocator.h:46,\r\n                 from vector:61,\r\n                 from test.cpp:1:\r\nnew_allocator.h: In instantiation of 'void std::__new_allocator<_Tp>::construct(_Up*, _Args&& ...) [with _Up = BaseAcceptor; _Args = {Derived*}; _Tp = BaseAcceptor]':\r\nalloc_traits.h:516:17:   required from 'static void std::allocator_traits<std::allocator<_Tp1> >::construct(allocator_type&, _Up*, _Args&& ...) [with _Up = BaseAcceptor; _Args = {Derived*}; _Tp = BaseAcceptor; allocator_type = std::allocator<BaseAcceptor>]'\r\nvector.tcc:117:30:   required from 'std::vector<_Tp, _Alloc>::reference std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {Derived*}; _Tp = BaseAcceptor; _Alloc = std::allocator<BaseAcceptor>; reference = BaseAcceptor&]'\r\nrequired from here\r\nnew_allocator.h:182:11: error: 'Base' is an inaccessible base of 'Derived'\r\n  182 |         { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }\r\n      |           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\nIn file included from vector:62:\r\nstl_construct.h: In instantiation of 'void std::_Construct(_Tp*, _Args&& ...) [with _Tp = BaseAcceptor; _Args = {Derived*}]':\r\nalloc_traits.h:635:19:   required from 'static void std::allocator_traits<std::allocator<void> >::construct(allocator_type&, _Up*, _Args&& ...) [with _Up = BaseAcceptor; _Args = {Derived*}; allocator_type = std::allocator<void>]'\r\nshared_ptr_base.h:604:39:   required from 'std::_Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp>::_Sp_counted_ptr_inplace(_Alloc, _Args&& ...) [with _Args = {Derived*}; _Tp = BaseAcceptor; _Alloc = std::allocator<void>; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]'\r\nshared_ptr_base.h:971:16:   required from 'std::__shared_count<_Lp>::__shared_count(_Tp*&, std::_Sp_alloc_shared_tag<_Alloc>, _Args&& ...) [with _Tp = BaseAcceptor; _Alloc = std::allocator<void>; _Args = {Derived*}; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]'\r\nshared_ptr_base.h:1712:14:   required from 'std::__shared_ptr<_Tp, _Lp>::__shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<void>; _Args = {Derived*}; _Tp = BaseAcceptor; __gnu_cxx::_Lock_policy _Lp = __gnu_cxx::_S_atomic]'\r\nshared_ptr.h:464:59:   required from 'std::shared_ptr<_Tp>::shared_ptr(std::_Sp_alloc_shared_tag<_Tp>, _Args&& ...) [with _Alloc = std::allocator<void>; _Args = {Derived*}; _Tp = BaseAcceptor]'\r\nshared_ptr.h:1009:14:   required from 'std::shared_ptr<typename std::enable_if<(! std::is_array< <template-parameter-1-1> >::value), _Tp>::type> std::make_shared(_Args&& ...) [with _Tp = BaseAcceptor; _Args = {Derived*}; typename enable_if<(! is_array< <template-parameter-1-1> >::value), _Tp>::type = BaseAcceptor]'\r\ntest.cpp:20:49:   required from here\r\nstl_construct.h:119:7: error: 'Base' is an inaccessible base of 'Derived'\r\n  119 |       ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);\r\n      |       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\r\n\r\n\/\/ msvc\r\nmemory(1630): error C2243: 'type cast': conversion from 'Derived *const ' to 'Base *' exists, but is inaccessible\r\ntest.cpp(19): note: see reference to function template instantiation 'std::unique_ptr<BaseAcceptor,std::default_delete<_Ty>> std::make_unique<BaseAcceptor,Derived*const >(Derived *const &&)' being compiled\r\n        with\r\n        [\r\n            _Ty=BaseAcceptor\r\n        ]\r\n\r\nvector(1604): warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify \/EHsc\r\nvector(1601): note: while compiling class template member function 'void std::vector<BaseAcceptor,std::allocator<_Ty>>::_Reallocate(unsigned __int64)'\r\n        with\r\n        [\r\n            _Ty=BaseAcceptor\r\n        ]\r\nvector(1631): note: see reference to function template instantiation 'void std::vector<BaseAcceptor,std::allocator<_Ty>>::_Reallocate(unsigned __int64)' being compiled\r\n        with\r\n        [\r\n            _Ty=BaseAcceptor\r\n        ]\r\ntest.cpp(22): note: see reference to class template instantiation 'std::vector<BaseAcceptor,std::allocator<_Ty>>' being compiled\r\n        with\r\n        [\r\n            _Ty=BaseAcceptor\r\n        ]\r\n\r\nmemory(901): error C2243: 'type cast': conversion from 'Derived *const ' to 'Base *' exists, but is inaccessible\r\nmemory(971): note: see reference to function template instantiation 'std::_Ref_count_obj<_Ty>::_Ref_count_obj<Derived*const >(Derived *const &&)' being compiled\r\n        with\r\n        [\r\n            _Ty=BaseAcceptor\r\n        ]\r\nmemory(971): note: see reference to function template instantiation 'std::_Ref_count_obj<_Ty>::_Ref_count_obj<Derived*const >(Derived *const &&)' being compiled\r\n        with\r\n        [\r\n            _Ty=BaseAcceptor\r\n        ]\r\ntest.cpp(20): note: see reference to function template instantiation 'std::shared_ptr<BaseAcceptor> std::make_shared<BaseAcceptor,Derived*const >(Derived *const &&)' being compiled\r\n<\/pre>\n
What does all this mean?<\/p>\n
The error boils down to this:<\/p>\n
\/\/ clang\r\nerror: cannot cast 'Derived' to its private base class 'Base'\r\n\r\n\/\/ gcc\r\nerror: 'Base' is an inaccessible base of 'Derived'\r\n\r\n\/\/ msvc\r\nerror C2243: 'type cast': conversion from 'Derived *const ' to 'Base *' exists, but is inaccessible\r\n<\/pre>\n
When Derived::DoSomething<\/code> constructs the BaseAcceptor<\/code> class, it passes its own this<\/code> as the constructor parameter. Inside that class’s own method, this<\/code> gives you a Derived*<\/code>.\u00b9 However, the constructor of BaseAcceptor<\/code> takes a Base*<\/code>. Fortunately, there is a conversion from Derived*<\/code> to Base*<\/code> available to Derived<\/code>, and the compiler performs that conversion in order to construct the BaseAcceptor<\/code>.<\/p>\n
On the other hand, if you use make_unique<\/code>, make_shared<\/code>, emplace_*<\/code>, or other functions that perfect-forward their parameters, the parameter is passed as a Derived*<\/code>. That Derived*<\/code> is then forwarded perfectly to the BaseAcceptor<\/code> constructor, and the compiler realizes, “Oh, wait, BaseAcceptor<\/code>‘s constructor doesn’t accept a Derived*<\/code>. Let me see if I can convert it.” And it can’t because the Derived*<\/code>-to-Base* conversion is not available to make_unique<\/code>.<\/p>\n
The conversion is not available because Base<\/code> is a private base class of Derived<\/code>. Only Derived<\/code> itself is allowed to access the Base<\/code> portion of Derived<\/code>, and that includes producing a pointer to it.<\/p>\n
The goal of perfect forwarding is to keep all the parameters in their original form, so that they reach their destination in their original form, without triggering a decay or copy or conversion or any other nonsense along the way.<\/p>\n
That’s great, but it also means that the conversion is deferred. What leaves the friendly confines of the Derived<\/code> class is a Derived*<\/code>, and when it is finally used to construct a BaseAcceptor<\/code>, the desired conversion is no longer available.<\/p>\n
Okay, now that we understand the problem, how do we fix it?<\/p>\n
One way is to force the conversion while still inside the Derived<\/code> class. That way, the conversion happens while it is still accessible.<\/p>\n
class Derived : Base\r\n{\r\n    void DoSomething()\r\n    {\r\n        auto p1 = std::make_unique<BaseAcceptor>(static_cast<Base*><\/span>(this));\r\n        auto p2 = std::make_shared<BaseAcceptor>(static_cast<Base*><\/span>(this));\r\n\r\n        std::vector<BaseAcceptor> v;\r\n        v.emplace_back(static_cast<Base*><\/span>(this));\r\n    }\r\n};\r\n<\/pre>\n
Another way is to make the conversion public.<\/p>\n
class Derived : public<\/span> Base\r\n{\r\n    void DoSomething()\r\n    {\r\n        auto p1 = std::make_unique<BaseAcceptor>(this);\r\n        auto p2 = std::make_shared<BaseAcceptor>(this);\r\n\r\n        std::vector<BaseAcceptor> v;\r\n        v.emplace_back(this);\r\n    }\r\n};\r\n<\/pre>\n
In this specific case, the private-ness of the Base<\/code> class was an accident, and it was intended to be public all along. Adding the public<\/code> keyword was the correct solution.<\/p>\n
\u00b9 I’m ignoring cv qualifiers here. You can put down your pitchforks.<\/p>\n","protected":false},"excerpt":{"rendered":"
Lazy conversion is too lazy.<\/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-107443","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Lazy conversion is too lazy.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107443","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=107443"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/107443\/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=107443"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=107443"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=107443"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}