Domyślne argumenty szablonu dla szablonów funkcji

Dlaczego domyślne argumenty szablonów są dozwolone tylko w szablonach klas? Dlaczego nie możemy zdefiniować domyślnego typu w szablonie funkcji członka? Na przykład:

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

Zamiast tego C ++ wymusza, aby domyślne argumenty szablonu były dozwolone tylko w szablonie klasy.

Podanie domyślnych argumentów szablonu ma sens. Na przykład możesz utworzyć funkcję sortowania:

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 wprowadza je do C ++. Zobacz ten raport wady Bjarne Stroustrup: Argumenty szablonów domyślnych dla szablonów funkcji i jego wypowiedzi

Zakaz domyślnych argumentów szablonów dla szablonów funkcji jest błędnie zapomnianym czasem, gdy funkcje wolnostojące były traktowane jak obywatele drugiej klasy i wymagały, aby wszystkie argumenty szablonu były wywnioskowane z argumentów funkcji, a nie określone.

Ograniczenie to poważnie ogranicza styl programowania, niepotrzebnie różnicując funkcje wolnostojące od funkcji składowych, co utrudnia pisanie kodu w stylu STL.

Cytować szablony C ++: Kompletny przewodnik (strona 207):

Kiedy szablony zostały pierwotnie dodane do języka C ++, jawne argumenty szablonu funkcji nie były prawidłową konstrukcją. Argumenty szablonu funkcji zawsze trzeba było wydedukować z wyrażenia wywołania. W rezultacie wydaje się, że nie ma istotnego powodu, aby zezwolić na domyślne argumenty szablonu funkcji, ponieważ domyślna wartość zawsze byłaby nadpisywana przez wartość wywnioskowaną.

Do tej pory wszystkie podane przykłady domyślnych parametrów szablonów dla szablonów funkcji można wykonać z przeciążeniem.

ARAK:

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

możliwe:

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

Mój własny:

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

możliwe:

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

możliwe:

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

Możliwe:

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

Co udowodniłem za pomocą następującego kodu:

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

Wydrukowany wynik odpowiada komentarzom dla każdego wywołania f, a wykomentowane wywołanie nie kompiluje się zgodnie z oczekiwaniami.

Podejrzewam więc, że domyślne parametry szablonu „nie są potrzebne”, ale prawdopodobnie tylko w tym samym sensie, że domyślne argumenty funkcji „nie są potrzebne”. Jak wskazuje raport defektów Stroustrupa, dodanie niededykowanych parametrów było zbyt późno, aby ktokolwiek zdał sobie sprawę i / lub naprawdę docenił, że sprawiło, że domyślne były przydatne. Obecna sytuacja jest więc oparta na wersji szablonów funkcji, która nigdy nie była standardowa.

W systemie Windows we wszystkich wersjach programu Visual Studio można przekonwertować ten błąd ( C4519 ) na ostrzeżenie lub wyłączyć go w następujący sposób:

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

Zobacz więcej szczegółów tutaj .

Używam następnej sztuczki:

Powiedzmy, że chcesz mieć taką funkcję:

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

Nie będziesz miał pozwolenia, ale robię to w następujący sposób:

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

W ten sposób możesz użyć go w następujący sposób:

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

Jak widzimy, nie ma potrzeby jawnego ustawiania drugiego parametru. Może przyda się komuś.