How is P0522R0 breaking code?

by

You can have code like this:

template<template<typename> typename>
struct Foo {};

template<typename, typename = void>
struct Bar {};

Foo<Bar> unused;

Without the defect resolution, unused would be ill-formed, because foo takes a template with only one template parameter, and not two. If you relied on this (maybe for SFINAE):

template<template<typename> typename>
void foo();

template<template<typename, typename> typename>
void foo();

template<typename, typename = void>
struct Bar {};

int main() {
    foo<Bar>(); // ambiguous after resolution!
}

Then the call would fail! The problem is that there was no corresponding change to partial ordering, and so both candidate functions have the same viability, and the call is ambiguous.

More Related Contents:

  1. reinterpret_cast creating a trivially default-constructible object
  2. Is the compiler allowed to optimize out heap memory allocations?
  3. Is stateful metaprogramming ill-formed (yet)?
  4. What made i = i++ + 1; legal in C++17?
  5. Is a pointer with the right address and type still always a valid pointer since C++17?
  6. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  7. std::ignore with structured bindings?
  8. Standard-layout and tail padding
  9. Deducing first template argument with other template parameters defaulted
  10. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  11. Self-initialization of a static constexpr variable, is it well-formed?
  12. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  13. Static member access in constant expressions
  14. Pointer interconvertibility vs having the same address
  15. Are C++17 Parallel Algorithms implemented already?
  16. Why doesn’t an if constexpr make this core constant expression error disappear?
  17. Is it allowed for a compiler to optimize away a local volatile variable?
  18. Injected class name compiler discrepancy
  19. Will I be able to declare a constexpr lambda inside a template parameter?
  20. What changes to C++ made copy initialization work for class with explicit constructor?
  21. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  22. Directly write into char* buffer of std::string
  23. How do inline variables work?
  24. How to enable C++17 compiling in Visual Studio?
  25. Class template argument deduction not working with alias template
  26. When do extra parentheses have an effect, other than on operator precedence?
  27. Conflict between copy constructor and forwarding constructor
  28. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  29. Is there a safe navigation operator for C++?
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment