{"id":109774,"date":"2024-05-17T07:00:00","date_gmt":"2024-05-17T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=109774"},"modified":"2024-08-16T08:59:53","modified_gmt":"2024-08-16T15:59:53","slug":"20240517-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20240517-00\/?p=109774","title":{"rendered":"Why can’t I find the injected name of a templated class’s templated base class?"},"content":{"rendered":"

Some time ago, I wrote about how injected class names were the C++ feature you didn’t even realize that you were using<\/a>. Injected class names let you use the plain name for the class being defined without needing to fully qualify it with namespaces and template parameters. Furthermore, injected class names are public and can be inherited.<\/p>\n

“But wait, I’m trying to use the injected class name of my base class, but the compiler won’t accept it.”<\/p>\n

template<typename T>\r\nstruct Base\r\n{\r\n    Base(T value);\r\n};\r\n\r\ntemplate<typename T>\r\nstruct Derived : Base<T>\r\n{\r\n    Derived(T value) : Base(value) {}\r\n};\r\n<\/pre>\n
This generates a compiler error.<\/p>\n
\/\/ clang\r\nerror: member initializer 'Base' does not name a non-static data member or base class\r\n\r\n    Derived(T value) : Base(value) {}\r\n                       ^~~~~~~~~~~\r\n\r\n\/\/ gcc\r\nerror: class 'Derived<T>' does not have any field named 'Base'\r\n\r\n    Derived(T value) : Base(value) {}\r\n                       ^~~~\r\n\r\n\/\/ msvc\r\nerror C2512: 'Base<T>': no appropriate default constructor available\r\nerror C2614: illegal member initialization: 'Base' is not a base or member\r\n<\/pre>\n
While it’s true that Base<\/code> is an injected type name of Base<\/code>, it is also a dependent type<\/i>, since its presence is indirectly dependent on the template type parameter T<\/code>. Specifically, the name Base<\/code> is provided by Base<T><\/code>, and that is dependent on T<\/code>.<\/p>\n
Now, you and I can plainly see that no matter how Base<T><\/code> is defined or specialized, there will always be a type named Base<\/code> that refers to Base<T><\/code> due to name injection, but the compiler doesn’t do this sort of fancy logical deduction.<\/p>\n
Consider this alternate formulation:<\/p>\n
template<typename T>\r\nstruct Base\r\n{\r\n    Base(int value);\r\n    using Type = T;\r\n};\r\n\r\ntemplate<typename T>\r\nstruct Derived : Base<T>\r\n{\r\n    Type m_value;\r\n};\r\n<\/pre>\n
Here, Type<\/code> is much more obviously a dependent type, since it is patently dependent on T<\/code>. (And you might have a specialization of Base<T><\/code> which defines Type<\/code> differently, or maybe doesn’t even define it at all.)<\/p>\n
One solution is to eschew the injected name and use the original full name:<\/p>\n
template<typename T>\r\nstruct Derived : Base<T>\r\n{\r\n    Derived(T value) : Base<T><\/span>(value) {}\r\n};\r\n<\/pre>\n
However, this can get clumsy if the base type name is unwieldy, say, because it comes from another namespace, or the template parameters are complex.<\/p>\n
template<typename T>\r\nstruct Derived :\r\n    Contoso::Faraway::Base<                      <\/span>\r\n        std::conditional_t<std::is_class_v<T>, T,<\/span>\r\n            std::tuple<T>>>                      <\/span>\r\n{\r\n    Derived(T value) :\r\n        Contoso::Faraway::Base<                      <\/span>\r\n            std::conditional_t<std::is_class_v<T>, T,<\/span>\r\n                std::tuple<T>>><\/span>(value) {}            <\/span>\r\n};\r\n<\/pre>\n
But wait, all is not lost. We just need to postpone the lookup to the second phase by making it a dependent type. And there are two common ways of doing this.<\/p>\n
At the time a template is parsed, non-dependent names are resolved immediately. The dependent names are resolved at the time a template is instantiated. This is known in the jargon as two-phase name lookup. Or as the LLVM blog once called it, the  dreaded<\/a> two-phase name lookup.<\/p>\n