İşlev şablonları için varsayılan şablon bağımsız değişkenleri

Varsayılan şablon bağımsız değişkenlerine neden yalnızca sınıf şablonlarında izin verilir? Üye işlev şablonunda neden varsayılan tür tanımlayamıyoruz? Örneğin:

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

Bunun yerine, C ++ varsayılan şablon bağımsız değişkenlerine yalnızca sınıf şablonunda izin verilmesini zorlar.

Varsayılan şablon bağımsız değişkenleri vermek mantıklıdır. Örneğin bir sıralama işlevi oluşturabilirsiniz:

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 onları C ++ ile tanıştırır. Bjarne Stroustrup'un bu hata raporuna bakın: İşlev Şablonları için Varsayılan Şablon Bağımsız Değişkenleri ve söyledikleri

Fonksiyon şablonları için varsayılan şablon argümanlarının yasaklanması, bağımsız fonksiyonların ikinci sınıf vatandaş olarak kabul edildiği ve tüm şablon argümanlarının belirtilmek yerine fonksiyon argümanlarından çıkarılması gereken zamanın yanlış anlaşılmış bir kalıntısıdır.

Kısıtlama, gereksiz işlevleri üye işlevlerinden farklı şekilde gereksiz hale getirerek programlama stilini ciddi şekilde sıkıştırır, böylece STL stili kod yazmayı zorlaştırır.

Alıntı C ++ şablonları: Complete Guide (sayfa 207):

Şablonlar başlangıçta C ++ diline eklendiğinde, açık işlev şablonu bağımsız değişkenleri geçerli bir yapı değildi. İşlev şablonu bağımsız değişkenleri her zaman çağrı ifadesinden çıkarılmalıdır. Sonuç olarak, varsayılan işlev şablonu bağımsız değişkenlerine izin vermek için zorlayıcı bir neden görünmüyordu, çünkü varsayılan her zaman çıkarılan değer tarafından geçersiz kılınır.

Şimdiye kadar, işlev şablonları için varsayılan şablon parametrelerinin tüm istenen örnekleri aşırı yüklerle yapılabilir.

arak:

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

olabilirdi:

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

Benim:

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

olabilirdi:

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

olabilirdi:

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

Olabilirdi:

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

Hangi aşağıdaki kod ile kanıtladı:

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

Yazdırılan çıktı, f'ye yapılan her çağrı için yorumları eşleştirir ve yorum yapılan çağrı beklendiği gibi derlenemez.

Bu nedenle, varsayılan şablon parametrelerinin "gerekli olmadığından", ancak muhtemelen yalnızca varsayılan işlev bağımsız değişkenlerinin "gerekli olmadığından" aynı olduğundan şüpheleniyorum. Stroustrup'un hata raporunun da belirttiği gibi, çıkarılmamış parametrelerin eklenmesi, herkesin varsayılanları yararlı hale getirdiğini fark etmesi ve / veya gerçekten takdir etmesi için çok geç oldu. Dolayısıyla mevcut durum, hiçbir zaman standart olmayan fonksiyon şablonlarının bir versiyonuna dayanmaktadır.

Windows'ta, Visual Studio'nun tüm sürümleriyle bu hatayı ( C4519 ) bir uyarıya dönüştürebilir veya şu şekilde devre dışı bırakabilirsiniz:

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

Daha fazla ayrıntıyı burada görebilirsiniz .

Ne kullanacağım bir sonraki hile:

Diyelim ki böyle bir işleve sahip olmak istiyorsunuz:

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

İzin verilmeyecek, ama bir sonraki yolu yapacağım:

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

Böylece bu şekilde kullanabilirsiniz:

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

Gördüğümüz gibi açıkça ikinci parametreyi ayarlamaya gerek yok. Belki biri için yararlı olacaktır.