Наследование шаблонного оператора = в С++ 14: различное поведение с g++ и clang++

Рассмотрим этот упрощенный код:

#include <iostream>

struct A
{
    template <int n = 1> void foo() { std::cout << n; }
};

struct B : public A
{
    using A::foo;
    template <int n = 2> void foo() { std::cout << n; }
};

int main()
{
    B obj;
    obj.foo();
}

Это печатает 2, как и должно быть с обоими компиляторами.

Если в производном классе уже есть класс с такой же сигнатурой, то он скрывает или переопределяет класс, введенный объявлением using. Подписи ваших операторов присваивания якобы одинаковы. Рассмотрим этот фрагмент:

template <typename U, 
          typename = std::enable_if_t<std::is_fundamental<U>::value>>
void bar(U) {}
template <typename U, 
          typename = std::enable_if_t<!std::is_fundamental<U>::value>>
void bar(U) {}

Это вызывает ошибку переопределения для bar в обоих компиляторах.

ОДНАКО, если изменить тип возвращаемого значения в одном из шаблонов, ошибка исчезнет!

Пришло время внимательно посмотреть на стандарт.

Когда использующий-декларатор переносит объявления из базового класса в производный класс, функции-члены и шаблоны функций-членов в производном классе переопределяют и/или скрывают функции-члены и шаблоны функций-членов с тем же именем, список-типов-параметров (11.3. 5), cv-qualification и ref-qualifier (если есть) в базовом классе (а не конфликтующие). Такие скрытые или переопределенные объявления исключаются из набора объявлений, введенных с помощью объявления-использования.

Что касается шаблонов, то это звучит сомнительно. Как вообще можно сравнивать два списка типов параметров, не сравнивая списки параметров шаблона? Первое зависит от второго. Действительно, абзац выше говорит:

Если объявление функции в области пространства имен или области блока имеет то же имя и тот же список типов параметров (11.3.5), что и функция, представленная объявлением использования, и объявления не объявляют одну и ту же функцию, программа плохо сформированный. Если объявление шаблона функции в области пространства имен имеет то же имя, список типов параметров, тип возвращаемого значения и список параметров шаблона, что и шаблон функции, представленный объявлением использования, программа имеет неправильный формат.

Это имеет гораздо больше смысла. Два шаблона одинаковы, если их списки параметров шаблона одинаковы, как и все остальное... но подождите, сюда входит и тип возвращаемого значения! Два шаблона одинаковы, если их имена и все в их подписях, включая возвращаемые типы (но не включая значения параметров по умолчанию), одинаковы. Тогда одно может конфликтовать с другим или скрывать его.

Так что же произойдет, если мы изменим возвращаемый тип оператора присваивания в B и сделаем его таким же, как в A? GCC перестает принимать код.

Итак, мой вывод таков:

1. Стандарт неясен, когда речь идет о шаблонах, скрывающих другие шаблоны, созданные с помощью объявлений. Если бы это означало исключить параметры шаблона из сравнения, это должно было бы быть указано и разъяснено возможные последствия. Например, может ли функция скрыть шаблон функции или наоборот? В любом случае в стандартном языке существует необъяснимое несоответствие между using в области пространства имен и using, которое приводит имена базовых классов к производному классу.
2. GCC, кажется, берет правило для using в области пространства имен и применяет его в контексте базового/производного класса.
3. Другие компиляторы делают что-то другое. Не слишком ясно, что именно; возможно, сравните списки типов параметров без учета параметров шаблона (или возвращаемых типов), как говорится в букве стандарта, но я не уверен, что это имеет смысл.

Примечание. Я считаю, что этот ответ неверен, а ответ н.м. является правильным . Я сохраню этот ответ, потому что я не уверен, но, пожалуйста, проверьте этот ответ.

Согласно [namespace.udecl]/15:

Когда объявление-использования переносит имена из базового класса в область действия производного класса, функции-члены и шаблоны функций-членов в производном классе переопределяют и/или скрывают функции-члены и шаблоны функций-членов с тем же именем, список типов параметров ([dcl.fct]), cv-qualification и ref-qualifier (если есть) в базовом классе (а не конфликтующие).

operator=, объявленный в производном классе B, имеет точно такое же имя, список типов параметров, квалификацию cv (нет) и квалификатор ссылки (нет), что и объявленный в A. Таким образом, функция, объявленная в B, скрывает код в A, а код имеет неправильный формат, поскольку разрешение перегрузки не находит подходящей функции для вызова. Однако списки параметров шаблона здесь не рассматриваются.

Так стоит ли их учитывать? Здесь стандарт становится неясным. Clang считает, что A и B имеют одинаковую (шаблонную) подпись, но не GCC. nm answer указывает, что реальная проблема на самом деле заключается в типе возвращаемого значения. (Аргументы шаблона по умолчанию никогда не учитываются при определении подписи.)

Обратите внимание, что это решается при поиске имени. Вывод шаблонного аргумента еще не выполняется, равно как и подстановка. Вы не можете сказать: «О, дедукция/подстановка не удалась, так что давайте добавим больше элементов в набор перегрузки». Так что SFINAE здесь не имеет значения.