函数模板的默认模板参数

为什么只在类模板上允许使用默认模板参数？为什么我们不能在成员函数模板中定义默认类型？例如：

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

相反，C ++强制仅在类模板上允许使用默认模板参数。

给出默认模板参数是有意义的。例如，您可以创建一个排序函数：

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将它们引入C ++。请参见Bjarne Stroustrup的以下缺陷报告：功能模板的默认模板参数及其说明

禁止将默认模板参数用作函数模板是在将独立函数视为第二类公民并要求从函数参数推导而不是指定所有模板参数的时代遗留下来的错误信息。

该限制通过不必要地使独立功能不同于成员函数而严重限制了编程风格，从而使编写STL风格的代码变得更加困难。

引用C ++模板：完整指南（第207页）：

最初将模板添加到C ++语言时，显式函数模板参数不是有效的构造。始终必须从调用表达式中推导函数模板参数。结果，似乎没有令人信服的理由允许默认函数模板参数，因为默认值总是会被​​推导的值覆盖。

到目前为止，功能模板的所有默认模板参数提供示例都可以通过重载完成。

阿拉克：

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

可能：

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

我自己的：

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

可能：

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

小玩意儿：

template<typename Iterator, typename Comp = std::less<Iterator> >
void sort(Iterator beg, Iterator end, Comp c = Comp())

可能：

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

可能：

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

我用以下代码证明了这一点：

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

打印的输出与对f的每次调用的注释匹配，并且注释掉的调用无法按预期编译。

因此，我怀疑默认模板参数“不需要”，但可能仅在与默认函数参数“不需要”相同的意义上。正如Stroustrup的缺陷报告所表明的那样，添加非推导参数对于任何人来说都太迟了，以至于没有人意识到和/或真正意识到它使默认设置有用。因此，当前的情况实际上是基于从来都不是标准功能模板的版本。

在Windows上，使用所有版本的Visual Studio，您都可以将此错误（C4519）转换为警告或将其禁用，如下所示：

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

在这里查看更多详细信息。

我使用的是下一个技巧：

假设您要具有以下功能：

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

您将不会被允许，但我会采取另一种方式：

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

因此，您可以这样使用它：

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

如我们所见，无需显式设置第二个参数。也许对某人有用。