Argumen templat default untuk templat fungsi

Mengapa argumen templat default hanya diizinkan pada templat kelas? Mengapa kita tidak bisa mendefinisikan tipe default di templat fungsi anggota? Sebagai contoh:

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

Sebaliknya, C ++ memaksa argumen templat default hanya diizinkan pada templat kelas.

Masuk akal untuk memberikan argumen templat default. Misalnya, Anda dapat membuat fungsi pengurutan:

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 memperkenalkan mereka ke C ++. Lihat laporan cacat ini oleh Bjarne Stroustrup: Argumen Templat Default untuk Templat Fungsi dan apa yang dia katakan

Larangan argumen templat default untuk templat fungsi adalah sisa yang salah waktu ketika fungsi bebas diperlakukan sebagai warga negara kelas dua dan mengharuskan semua argumen templat disimpulkan dari argumen fungsi alih-alih ditentukan.

Pembatasan serius kram gaya pemrograman dengan tidak perlu membuat fungsi berdiri bebas berbeda dari fungsi anggota, sehingga membuatnya lebih sulit untuk menulis kode gaya STL.

Mengutip Template C ++: Panduan Lengkap (halaman 207):

Ketika templat awalnya ditambahkan ke bahasa C ++, argumen templat fungsi eksplisit bukan konstruk yang valid. Argumen templat fungsi selalu harus dikurangkan dari ekspresi panggilan. Akibatnya, tampaknya tidak ada alasan kuat untuk mengizinkan argumen templat fungsi default karena default akan selalu ditimpa oleh nilai yang dideduksi.

Sejauh ini, semua contoh parameter templat default yang disodorkan untuk templat fungsi dapat dilakukan dengan kelebihan beban.

AraK:

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

bisa jadi:

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

Saya sendiri:

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

bisa jadi:

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

bisa jadi:

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

Bisa jadi:

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

Yang saya buktikan dengan kode berikut:

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

Output yang dicetak cocok dengan komentar untuk setiap panggilan ke f, dan panggilan yang dikomentari gagal untuk mengkompilasi seperti yang diharapkan.

Jadi saya menduga bahwa parameter templat default "tidak diperlukan", tetapi mungkin hanya dalam arti yang sama bahwa argumen fungsi default "tidak diperlukan". Seperti yang ditunjukkan oleh laporan cacat Stroustrup, penambahan parameter yang tidak dideduksikan sudah terlambat bagi siapa pun untuk menyadari dan / atau benar-benar menghargai bahwa itu membuat default berguna. Jadi situasi saat ini berlaku berdasarkan versi templat fungsi yang tidak pernah standar.

Pada Windows, dengan semua versi Visual Studio Anda dapat mengubah kesalahan ini ( C4519 ) menjadi peringatan atau menonaktifkannya seperti ini:

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

Lihat lebih detail di sini .

Apa yang saya gunakan adalah trik selanjutnya:

Katakanlah Anda ingin memiliki fungsi seperti ini:

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

Anda tidak akan diizinkan, tetapi saya lakukan selanjutnya:

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

Jadi dengan cara ini Anda dapat menggunakannya seperti ini:

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

Seperti yang dapat kita lihat, tidak perlu secara eksplisit mengatur parameter kedua. Mungkin itu akan bermanfaat bagi seseorang.