Argumentos de modelo padrão para modelos de função

Por que argumentos de modelo padrão são permitidos apenas em modelos de classe? Por que não podemos definir um tipo padrão em um modelo de função de membro? Por exemplo:

struct mycclass {
  template<class T=int>
  void mymember(T* vec) {
    // ...
  }
};

Em vez disso, o C ++ força que os argumentos padrão do modelo sejam permitidos apenas em um modelo de classe.

Faz sentido fornecer argumentos de modelo padrão. Por exemplo, você pode criar uma função de classificação:

template<typename Iterator, 
         typename Comp = std::less<
            typename std::iterator_traits<Iterator>::value_type> >
void sort(Iterator beg, Iterator end, Comp c = Comp()) {
  ...
}

O C ++ 0x os apresenta ao C ++. Veja este relatório de defeitos de Bjarne Stroustrup: Argumentos de modelo padrão para modelos de função e o que ele diz

A proibição de argumentos de modelo padrão para modelos de função é um remanescente errado do tempo em que as funções independentes foram tratadas como cidadãos de segunda classe e exigiram que todos os argumentos do modelo fossem deduzidos dos argumentos da função em vez de especificados.

A restrição contraria seriamente o estilo de programação, tornando desnecessariamente diferentes as funções independentes das funções de membro, dificultando a gravação de código no estilo STL.

Para citar os modelos C ++: O guia completo (página 207):

Quando os modelos foram originalmente adicionados à linguagem C ++, os argumentos explícitos do modelo de função não eram uma construção válida. Os argumentos do modelo de função sempre precisavam ser dedutíveis da expressão de chamada. Como resultado, parecia não haver motivo convincente para permitir argumentos de modelo de função padrão, porque o padrão sempre seria substituído pelo valor deduzido.

Até o momento, todos os exemplos apresentados de parâmetros de modelo padrão para modelos de função podem ser feitos com sobrecargas.

AraK:

struct S { 
    template <class R = int> R get_me_R() { return R(); } 
};

poderia ser:

struct S {
    template <class R> R get_me_R() { return R(); } 
    int get_me_R() { return int(); }
};

Meu próprio:

template <int N = 1> int &increment(int &i) { i += N; return i; }

poderia ser:

template <int N> int &increment(int &i) { i += N; return i; }
int &increment(int &i) { return increment<1>(i); }

litb:

template<typename Iterator, typename Comp = std::less<Iterator> >
void sort(Iterator beg, Iterator end, Comp c = Comp())

poderia ser:

template<typename Iterator>
void sort(Iterator beg, Iterator end, std::less<Iterator> c = std::less<Iterator>())

template<typename Iterator, typename Comp >
void sort(Iterator beg, Iterator end, Comp c = Comp())

Stroustrup:

template <class T, class U = double>
void f(T t = 0, U u = 0);

Poderia ser:

template <typename S, typename T> void f(S s = 0, T t = 0);
template <typename S> void f(S s = 0, double t = 0);

O que eu provei com o seguinte código:

#include <iostream>
#include <string>
#include <sstream>
#include <ctype.h>

template <typename T> T prettify(T t) { return t; }
std::string prettify(char c) { 
    std::stringstream ss;
    if (isprint((unsigned char)c)) {
        ss << "'" << c << "'";
    } else {
        ss << (int)c;
    }
    return ss.str();
}

template <typename S, typename T> void g(S s, T t){
    std::cout << "f<" << typeid(S).name() << "," << typeid(T).name()
        << ">(" << s << "," << prettify(t) << ")\n";
}


template <typename S, typename T> void f(S s = 0, T t = 0){
    g<S,T>(s,t);
}

template <typename S> void f(S s = 0, double t = 0) {
    g<S,double>(s, t);
}

int main() {
        f(1, 'c');         // f<int,char>(1,'c')
        f(1);              // f<int,double>(1,0)
//        f();               // error: T cannot be deduced
        f<int>();          // f<int,double>(0,0)
        f<int,char>();     // f<int,char>(0,0)
}

A saída impressa corresponde aos comentários de cada chamada para f e a chamada comentada falha ao compilar conforme o esperado.

Portanto, suspeito que os parâmetros padrão do modelo "não são necessários", mas provavelmente apenas no mesmo sentido em que argumentos de função padrão "não são necessários". Como o relatório de defeitos da Stroustrup indica, a adição de parâmetros não deduzidos era tarde demais para alguém perceber e / ou realmente apreciar que isso tornava os padrões úteis. Portanto, a situação atual é baseada em uma versão dos modelos de função que nunca foi padrão.

No Windows, com todas as versões do Visual Studio, você pode converter esse erro ( C4519 ) em um aviso ou desabilitá-lo da seguinte forma:

#ifdef  _MSC_VER
#pragma warning(1 : 4519) // convert error C4519 to warning
// #pragma warning(disable : 4519) // disable error C4519
#endif

Veja mais detalhes aqui .

O que eu uso é o próximo truque:

Vamos dizer que você deseja ter uma função como esta:

template <typename E, typename ARR_E = MyArray_t<E> > void doStuff(ARR_E array)
{
    E one(1);
    array.add( one );
}

Você não será permitido, mas eu faço da próxima maneira:

template <typename T>
struct MyArray_t {
void add(T i) 
{
    // ...
}
};

template <typename E, typename ARR_E = MyArray_t<E> >
class worker {
public:
    /*static - as you wish */ ARR_E* parr_;
    void doStuff(); /* do not make this one static also, MSVC complains */
};

template <typename E, typename ARR_E>
void worker<E, ARR_E>::doStuff()
{
    E one(1);
    parr_->add( one );
}

Portanto, você pode usá-lo desta maneira:

MyArray_t<int> my_array;
worker<int> w;
w.parr_ = &arr;
w.doStuff();

Como podemos ver, não é necessário definir explicitamente o segundo parâmetro. Talvez seja útil para alguém.