Argomenti modello predefiniti per modelli funzione

Perché gli argomenti del modello predefinito sono consentiti solo sui modelli di classe? Perché non possiamo definire un tipo predefinito in un modello di funzione membro? Per esempio:

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

Al contrario, C ++ impone che gli argomenti modello predefiniti siano consentiti solo su un modello di classe.

Ha senso fornire argomenti di modello predefiniti. Ad esempio, è possibile creare una funzione di ordinamento:

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

C ++ 0x li introduce in C ++. Vedi questo rapporto sui difetti di Bjarne Stroustrup: Argomenti modello predefinito per modelli funzione e cosa dice

Il divieto di argomenti di modello predefiniti per i modelli di funzione è un residuo errato del tempo in cui le funzioni indipendenti sono state trattate come cittadini di seconda classe e hanno richiesto che tutti gli argomenti del modello fossero dedotti dagli argomenti della funzione anziché specificati.

La restrizione restringe gravemente lo stile di programmazione rendendo inutilmente diverse le funzioni autoportanti dalle funzioni membro, rendendo così più difficile la scrittura di codice in stile STL.

Per citare i modelli C ++: La guida completa (pagina 207):

Quando i modelli venivano originariamente aggiunti al linguaggio C ++, gli argomenti espliciti dei modelli di funzione non erano un costrutto valido. Gli argomenti del modello di funzione dovevano sempre essere deducibili dall'espressione della chiamata. Di conseguenza, non sembra esistere alcun motivo valido per consentire gli argomenti del modello di funzione predefinito poiché il valore predefinito verrà sempre ignorato dal valore dedotto.

Finora, tutti gli esempi offerti di parametri di modello predefiniti per i modelli di funzione possono essere eseguiti con sovraccarichi.

ARAK:

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

potrebbe essere:

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

Il mio:

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

potrebbe essere:

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())

potrebbe essere:

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);

Potrebbe essere:

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

Che ho dimostrato con il seguente codice:

#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)
}

L'output stampato corrisponde ai commenti di ciascuna chiamata a f e la chiamata commentata non viene compilata come previsto.

Quindi sospetto che i parametri del modello predefinito "non siano necessari", ma probabilmente solo nello stesso senso in cui gli argomenti della funzione predefinita "non sono necessari". Come indica il rapporto sui difetti di Stroustrup, l'aggiunta di parametri non dedotti era troppo tardi perché qualcuno potesse rendersi conto e / o apprezzare davvero che rendeva utili le impostazioni predefinite. Quindi la situazione attuale è in effetti basata su una versione di modelli di funzioni che non è mai stata standard.

Su Windows, con tutte le versioni di Visual Studio è possibile convertire questo errore ( C4519 ) in un avviso o disabilitarlo in questo modo:

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

Vedi maggiori dettagli qui .

Quello che uso è il prossimo trucco:

Diciamo che vuoi avere una funzione come questa:

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

Non ti sarà permesso, ma lo farò nel modo seguente:

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 );
}

Quindi in questo modo puoi usarlo in questo modo:

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

Come possiamo vedere, non è necessario impostare esplicitamente il secondo parametro. Forse sarà utile per qualcuno.