descargar - Ambigüedad de la deducción de la plantilla de g++ 8.1 con indicador estándar igual a ''c++ 17''

gcc ultima version

Question

Tengo un código que es interpretado de manera diferente por g ++ con las banderas estándar c++14 y c++17 :

#include <iostream>
#include <vector>

template<class T, class A>
void func(const std::vector<T, A>&v)
{
    std::cout << 1 << std::endl;
}

template<typename T, template <typename>class Vector>
void func(const Vector<T>&v)
{
    std::cout << 2 << std::endl;
}

void f()
{
    std::vector<int> v;
    func(v);
}

int main()
{
    f();
    return 0;
}

Cuando estoy tratando de compilar este código con comando

g ++ -std = c ++ 14 -Wall -pedantic main.cpp

todo funciona bien

Pero cuando estoy tratando de compilar este código con comando

g ++ -std = c ++ 17 -Wall -pedantic main.cpp

Me sale este error:

main.cpp: In function ''void f()'':
main.cpp:19:11: error: call of overloaded ''func(std::vector<int>&)'' is ambiguous
     func(v);
           ^
main.cpp:5:6: note: candidate: ''void func(const std::vector<_Tp, _Alloc>&) [with T = int; A = std::allocator<int>]''
 void func(const std::vector<T, A>&v)
      ^~~~
main.cpp:11:6: note: candidate: ''void func(const Vector<T>&) [with T = int; Vector = std::vector]''
 void func(const Vector<T>&v)

No puedo entender qué está mal con este código desde el punto de vista del estándar C ++ 17.

Answer 1

El comportamiento cambió desde C ++ 17.

Antes de C ++ 17, el código funciona porque std::vector tiene dos parámetros de plantilla (el segundo tiene el argumento predeterminado std::allocator<T> ), mientras que el parámetro de plantilla de Vector se declara que tiene solo uno, no no coincide entonces la segunda func no será considerada.

Desde C ++ 17 ( CWG 150 ), los argumentos de plantilla predeterminados se permiten para que un argumento de plantilla de plantilla coincida con un parámetro de plantilla de plantilla con menos parámetros de plantilla. Eso significa que ambas func convierten en candidatos válidos y luego conduce a la ambigüedad.

template<class T> class A { /* ... */ };
template<class T, class U = T> class B { /* ... */ };

template<template<class> class P> class X { /* ... */ };

X<A> xa; // OK
X<B> xb; // OK in C++17 after CWG 150
         // Error earlier: not an exact match