Standardvorlagenargumente für Funktionsvorlagen

Warum sind Standardvorlagenargumente nur für Klassenvorlagen zulässig? Warum können wir keinen Standardtyp in einer Elementfunktionsvorlage definieren? Beispielsweise:

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

Stattdessen erzwingt C ++, dass Standardvorlagenargumente nur für eine Klassenvorlage zulässig sind.

Es ist sinnvoll, Standardvorlagenargumente anzugeben. Zum Beispiel könnten Sie eine Sortierfunktion erstellen:

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 führt sie in C ++ ein. Siehe diesen Fehlerbericht von Bjarne Stroustrup: Standardvorlagenargumente für Funktionsvorlagen und was er sagt

Das Verbot von Standardvorlagenargumenten für Funktionsvorlagen ist ein falsch verstandener Rest der Zeit, in der freistehende Funktionen als Bürger zweiter Klasse behandelt wurden und alle Vorlagenargumente aus den Funktionsargumenten abgeleitet und nicht angegeben werden mussten.

Die Einschränkung schränkt den Programmierstil erheblich ein, indem freistehende Funktionen unnötig von Elementfunktionen unterschieden werden, wodurch das Schreiben von Code im STL-Stil erschwert wird.

So zitieren Sie C ++ - Vorlagen: Das vollständige Handbuch (Seite 207):

Wenn Vorlagen ursprünglich zur C ++ - Sprache hinzugefügt wurden, waren explizite Funktionsvorlagenargumente kein gültiges Konstrukt. Funktionsvorlagenargumente mussten immer aus dem Aufrufausdruck ableitbar sein. Infolgedessen schien es keinen zwingenden Grund zu geben, Argumente für Standardfunktionsvorlagen zuzulassen, da der Standard immer durch den abgeleiteten Wert überschrieben würde.

Bisher können alle angebotenen Beispiele für Standardvorlagenparameter für Funktionsvorlagen mit Überladungen erstellt werden.

AraK:

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

könnte sein:

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

Mein eigenes:

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

könnte sein:

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

könnte sein:

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

Könnte sein:

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

Was ich mit folgendem Code bewiesen habe:

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

Die gedruckte Ausgabe stimmt mit den Kommentaren für jeden Aufruf von f überein, und der auskommentierte Aufruf kann nicht wie erwartet kompiliert werden.

Ich vermute also, dass Standardvorlagenparameter "nicht benötigt" werden, aber wahrscheinlich nur in dem Sinne, dass Standardfunktionsargumente "nicht benötigt werden". Wie aus dem Fehlerbericht von Stroustrup hervorgeht, war das Hinzufügen nicht abgeleiteter Parameter zu spät, als dass jemand erkennen und / oder wirklich einschätzen könnte, dass dies die Standardeinstellungen nützlich machte. Die aktuelle Situation basiert also auf einer Version von Funktionsvorlagen, die nie Standard war.

Unter Windows können Sie mit allen Versionen von Visual Studio diesen Fehler ( C4519 ) in eine Warnung konvertieren oder wie folgt deaktivieren:

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

Weitere Details finden Sie hier .

Was ich benutze, ist der nächste Trick:

Nehmen wir an, Sie möchten eine Funktion wie diese haben:

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

Du wirst nicht erlaubt sein, aber ich mache den nächsten Weg:

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

Auf diese Weise können Sie es folgendermaßen verwenden:

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

Wie wir sehen können, muss der zweite Parameter nicht explizit eingestellt werden. Vielleicht ist es für jemanden nützlich.