Đối số mẫu mặc định cho các mẫu hàm

Tại sao các đối số mẫu mặc định chỉ được phép trên các mẫu lớp? Tại sao chúng ta không thể xác định loại mặc định trong mẫu hàm thành viên? Ví dụ:

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

Thay vào đó, C ++ buộc các đối số mẫu mặc định chỉ được phép trên một mẫu lớp.

Nó có ý nghĩa để đưa ra các đối số mẫu mặc định. Ví dụ: bạn có thể tạo một hàm sắp xếp:

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 giới thiệu chúng với C ++. Xem báo cáo lỗi này của Bjarne Stroustrup: Đối số mẫu mặc định cho các mẫu chức năng và những gì ông nói

Việc cấm các đối số mẫu mặc định cho các mẫu hàm là phần còn lại của thời gian mà các hàm tự do được coi là công dân hạng hai và yêu cầu tất cả các đối số mẫu phải được suy ra từ các đối số hàm thay vì được chỉ định.

Hạn chế nghiêm trọng làm chùn bước phong cách lập trình bằng cách làm cho các hàm độc lập không cần thiết khác với các hàm thành viên, do đó làm cho việc viết mã kiểu STL trở nên khó khăn hơn.

Để trích dẫn Mẫu C ++: Hướng dẫn hoàn chỉnh (trang 207):

Khi các mẫu ban đầu được thêm vào ngôn ngữ C ++, các đối số mẫu hàm rõ ràng không phải là một cấu trúc hợp lệ. Các đối số mẫu hàm luôn phải được khấu trừ từ biểu thức cuộc gọi. Kết quả là, dường như không có lý do thuyết phục nào để cho phép các đối số mẫu hàm mặc định bởi vì mặc định sẽ luôn bị ghi đè bởi giá trị được suy ra.

Cho đến nay, tất cả các ví dụ phổ biến về các tham số mẫu mặc định cho các mẫu hàm có thể được thực hiện với tình trạng quá tải.

AraK:

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

có thể là:

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

Của riêng tôi:

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

có thể là:

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

có thể là:

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

Có thể là:

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

Mà tôi đã chứng minh với đoạn mã sau:

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

Đầu ra được in khớp với các nhận xét cho mỗi cuộc gọi đến f và cuộc gọi nhận xét không thể biên dịch như mong đợi.

Vì vậy, tôi nghi ngờ rằng các tham số mẫu mặc định "không cần thiết", nhưng có lẽ chỉ theo nghĩa tương tự rằng các đối số chức năng mặc định "không cần thiết". Như báo cáo lỗi của Stroustrup chỉ ra, việc bổ sung các tham số không suy diễn là quá muộn để bất kỳ ai nhận ra và / hoặc thực sự đánh giá cao rằng nó làm cho mặc định trở nên hữu ích. Vì vậy, tình hình hiện tại có hiệu lực dựa trên một phiên bản của các mẫu chức năng không bao giờ là tiêu chuẩn.

Trên Windows, với tất cả các phiên bản Visual Studio, bạn có thể chuyển đổi lỗi này ( C4519 ) thành cảnh báo hoặc vô hiệu hóa như vậy:

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

Xem thêm chi tiết tại đây .

Những gì tôi sử dụng là thủ thuật tiếp theo:

Hãy nói rằng bạn muốn có chức năng như thế này:

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

Bạn sẽ không được phép, nhưng tôi làm theo cách tiếp theo:

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

Vì vậy, theo cách này bạn có thể sử dụng nó như thế này:

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

Như chúng ta có thể thấy không cần thiết phải đặt tham số thứ hai một cách rõ ràng. Có lẽ nó sẽ hữu ích cho một ai đó.