Почему аргумент по умолчанию нельзя добавить позже в функциях шаблона?

Question

C++ стандартный раздел 8.3.6.4 говорит, что

Для функций, не шаблонных, аргументы по умолчанию могут быть добавлены в более поздние декларации функции в той же области. [...]

Но мой вопрос в том, почему он не допускается для функций шаблона? В чем причина не допускать добавления аргументов по умолчанию в более поздние объявления в той же области для функций шаблона?

Рассмотрите эту программу, которая компилируется в порядке. (Не шаблон функции) (см видеодемонстрацию here.)

#include <iostream> 

int f(int a,int b,int c=3); 
int f(int a,int b=9,int c); // default argument in middle, ok allowed 

int main() 
{ 
    f(3); 
    f(3,6); 
    f(3,6,9); 
    return 0; 
} 

int f(int a,int b,int c) 
{ 
    std::cout<<a<<' '<<b<<' '<<c<<'\n'; 
    return 0; 
} 

Но после проваливается в компиляции. (Шаблон функции) (см демо here.)

#include <iostream> 

template <typename T> 
void f(T a,int b,int c=3); 
template <typename T> 
void f(T a,int b=9,int c); // compiler error why??? 

int main() 
{ 
    f(3); 
    f(3,6); 
    f(3,6,9); 
    return 0; 
} 

template <typename T> 
void f(T a,int b,int c) 
{ 
    std::cout<<a<<' '<<b<<' '<<c<<'\n'; 
} 

Answer 1

Это историческое ограничение, которое было добавлено довольно рано в процессе стандартизации (оно было на C++ 98, но не в ARM).

Я не помню точной причины (и мой коллега, который почти наверняка был там, когда было принято решение). Тем не менее, у меня есть предположение ...

В то время все-единственные компиляторы создавали шаблоны, переигрывая токены через синтаксический анализ. Некоторые едва разбирались в шаблонах. Рассмотрим:

template<class T> struct S { 
    T f(T); // (1) 
}; 
template<class T> T S<T>::f(T p = 42) { return p; } // (2) 
S<int> s; // Causes the "real" parsing of (1), but not (2). 
int r = s.f(); // (3) 

При решении вызова (3), более старые компиляторы поэтому часто только имели доступ к реализованным декларации (1), а (2) по-прежнему не очень разбирается (только маркер-буфер). В результате такие компиляторы не знали о добавленном аргументе по умолчанию в (3).

Является ли подозрительная осторожность, поэтому комитет решает в целом запретить добавленные аргументы по умолчанию в шаблонах.

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

Answer 2

Потому что это принципиально невозможно.

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

Для обычных функций без шаблонов это ужасная идея, но по-прежнему возможна, потому что вам просто нужно сопоставить типы аргументов и выполненную работу.

К сожалению, для функций шаблона это становится ... более сложным. Рассмотрим:

template<typename T> void f(T t); 
template<typename U> std::enable_if_t<std::is_same<U, int>::value> f(U u = U()); 

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