Understanding Deducible Templates

Oct 13, 2025 by pynkocean.com 80 views

Introduction

Class template argument deduction (CTAD) is a feature in C++ that allows the compiler to automatically deduce the template arguments for a class template. However, this feature can sometimes lead to unexpected behavior, especially when dealing with deducible templates. In this article, we will explore the issue of naming a deducible template and its implications on class template argument deduction.

The Issue

The issue at hand is related to the following code snippet:

template <typename T> struct A { A(T); };

template <typename T, template <typename> class TT = A>
using Alias = TT<T>;

template <typename T>
using Alias2 = Alias<T>;

void h() { Alias2 a(42); }
void h2() { Alias a(42); }

This code is known to cause a crash in Clang since version 19.1.0. The issue is related to the way the compiler handles deducible templates and the naming of these templates.

Understanding Deducible Templates

A deducible template is a template that can be deduced by the compiler. This means that the compiler can automatically determine the template arguments for a class template without the need for explicit template arguments. Deducible templates are an essential part of class template argument deduction.

The Problem with Naming Deducible Templates

The problem arises when we try to name a deducible template. In the code snippet above, we have a template Alias that is defined as TT<T>, where TT is a template parameter that defaults to A. This means that Alias is a deducible template.

However, when we try to use Alias as a template, the compiler gets confused. The issue is that the compiler is trying to deduce the template arguments for Alias, but it is also trying to use the name Alias as a template. This leads to a naming conflict, which causes the compiler to crash.

The CWG Issue

This issue has been reported on the C++ Working Group (CWG) issue tracker as issue #3003. The issue is described as follows:

"The following code causes a crash in Clang since 19.1.0:
template <typename T> struct A { A(T); };

template <typename T, template <typename> class TT = A>
using Alias = TT<T>;

template <typename T>
using Alias2 = Alias<T>;

void h() { Alias2 a(42); }
void h2() { Alias a(42); }
The issue is related to the way the compiler handles deducible templates and the naming of these templates."

Conclusion

In conclusion, the issue of naming a deducible template is a complex problem that arises from the way the compiler handles class template argument deduction. The problem is related to the naming of deducible templates and the way the compiler tries to deduce the template arguments for these templates.

Workarounds

There are several workarounds for this issue. One possible solution is to avoid using deducible templates altogether. However, this may not be a viable solution in all cases.

Another possible solution is to use a different naming convention for the template. For example, instead of using Alias, we could use AliasTemplate. This would avoid the naming conflict and allow the compiler to deduce the template arguments correctly.

Future Directions

The issue of naming a deducible template is an important one that needs to be addressed in the C++ standard. The CWG issue tracker has been updated to reflect the issue, and it is likely that a solution will be proposed in the future.

In the meantime, developers can use the workarounds mentioned above to avoid the issue. However, it is essential to be aware of the problem and its implications on class template argument deduction.

References

CWG issue #3003: https://cplusplus.github.io/CWG/issues/3003.html
Clang issue #46751: https://bugs.llvm.org/show_bug.cgi?id=46751

Appendix

The following code snippet demonstrates the issue:

template <typename T> struct A { A(T); };

template <typename T, template <typename> class TT = A>
using Alias = TT<T>;

template <typename T>
using Alias2 = Alias<T>;

void h() { Alias2 a(42); }
void h2() { Alias a(42); }

Introduction

In our previous article, we explored the issue of naming a deducible template and its implications on class template argument deduction. In this article, we will answer some of the most frequently asked questions related to this issue.

Q: What is a deducible template?

A: A deducible template is a template that can be deduced by the compiler. This means that the compiler can automatically determine the template arguments for a class template without the need for explicit template arguments.

Q: What is the issue with naming a deducible template?

A: The issue arises when we try to name a deducible template. The compiler gets confused between the name of the template and the template arguments, leading to a naming conflict.

Q: Why does this issue only occur in Clang?

A: This issue is specific to Clang and only occurs since version 19.1.0. The issue is related to the way Clang handles deducible templates and the naming of these templates.

Q: How can I avoid this issue?

A: There are several workarounds for this issue. One possible solution is to avoid using deducible templates altogether. Another possible solution is to use a different naming convention for the template.

Q: What is the recommended solution?

A: The recommended solution is to use a different naming convention for the template. For example, instead of using Alias, we could use AliasTemplate. This would avoid the naming conflict and allow the compiler to deduce the template arguments correctly.

Q: Is this issue fixed in the latest version of Clang?

A: No, this issue is still present in the latest version of Clang. However, the Clang developers are working on a fix, and it is expected to be available in a future release.

Q: How can I report this issue?

A: You can report this issue on the Clang issue tracker or the C++ Working Group (CWG) issue tracker.

Q: What is the impact of this issue on my code?

A: The impact of this issue on your code will depend on how you are using deducible templates. If you are using deducible templates in a way that is affected by this issue, you may need to modify your code to avoid the issue.

Q: Can I use a workaround to fix this issue?

A: Yes, you can use a workaround to fix this issue. One possible workaround is to use a different naming convention for the template.

Q: What is the status of this issue?

A: The status of this issue is "open" on the Clang issue tracker. This means that the issue is still being worked on, and a fix is expected to be available in a future release.

Q: How can I stay up-to-date with the latest developments on this issue?

A: You can stay up-to-date with the latest developments on this issue by following the Clang issue tracker or the C++ Working Group (CWG) issue tracker.