http://stackoverflow.com/questions/851584/default-template-class-argument-confuses-g

跟我遇到的问题一样，翻译了一小部分，作为笔记，如果哪个地方理解错误请一定指出。英语好的可以直接略过这篇文章了。

不得不感叹模板编程遇到的问题真难理解。

先写个例子程序：

template<typename A,typename B>

class Foo {};

struct Bar {

void method( Foo<int,int> const &stuff = Foo<int,int>());

};

int main()

{

return 0;

}

如果Foo是单模板的话，没有问题的。

编译了下，看下输出：

$ g++-4.3 test.cpp

test.cpp:5: error: expected ‘,’ or ‘...’ before ‘>’ token

test.cpp:5: error: wrong number of template arguments (1, should be 2)

test.cpp:2: error: provided for ‘template<class A, class B> class Foo’

test.cpp:5: error: default argument missing for parameter 2 of ‘void Bar::method(const Foo<int, int>&, int)’

$ g++-4.4 test.cpp

$

可以看到g++4.3编译错误，g++4.4却编译的过。

接下来为了阐述这个问题，我统一使用g++4.3来编译。

编译器认为我想要写这么一个函数：

void Bar::method(const Foo<int, int>&, int)

可见编译器理解错了变量类型，用typedef指定一下看看，修改上面的例子：

struct Bar {

typedef Foo<int,int> FooType;

void method( FooType const &stuff = FooType());

};

编译通过！

不过到底是为什么呢？

先看下这么修改行不行？

struct Bar {

void method( Foo<int,int> const &stuff = (Foo<int,int>()));

};

加了括号，同样可以~~

为了说清楚，先看一下以下的代码：

struct Bar {

void method(int i = j);//’j’ not declared yet

static const int j = 0;

};

这样编译是没有问题的，尽管j未声明，但编译器可以分析出j来。

而编译器是这么看待我们最上面的代码的：

void method ( Foo<int,int> const& stuff = Foo<int // Arg 1 with dflt.

, int>() ); // Arg 2 - syntax error

这就不难理解编译器报的错误了，增加了一对括号可以保证编译器理解正确。

同时，The following case shows an example where g++ succeeds but Comeau still generates a syntax error:

template<int J, int K>

class Foo { };

struct Bar {

void method ( Foo<0, 0> const & i = ( Foo<j, k> () ) );

static const int j = 0;

static const int k = 0;

};

继续延伸一下，为什么多参数的函数调用放在同样的位置不会出错呢？比如：

int foo(int,int,int);

struct Bar {

void method(int i = foo(0,0,0));

};

因为编译器是这么理解上面的代码的：

int foo (int, int, int);

struct Bar {

void method ( int j =

foo (0, 0, 0) ); // Comma's here are inside ( )

};

为什么编译器在这里理解对了呢？其实不难猜测，C++要求所有的括号必须配对，’(’就意味着有一个’)’在后面。但模板参数里的’<’不同，C++允许对’<’重载。

The reason for the problem here is that '<' does not need to be matched, since it is overloaded in C++ and so can be the less than operator or the start of a template argument list.

看下这个例子就明白了：

template<int I, int J>

class Foo { };

struct Bar {

template <typename T> struct Y { };

void method ( ::Foo<0,0> const& stuff = Foo<10 , Y < int > = Y<int>() );

struct X {

::Foo<0, 0> operator< (int);

};

static X Foo;

};

编译没有问题，因为这里没有什么默认模板参数，实际上是两个参数。。。。。。

#include <vector>

template<typename T>

class Foo {

};

template<typename T>

void method()

{

std::vector<Foo<T> > vecFoo;

std::vector<Foo<T> >::iterator iter = vecFoo.begin();

}

编译是通不过的。

解决办法：

typename std::vector<Foo<T> >::iterator iter = vecFoo.begin();

就可以了。

Effective C++:了解typename的双重意义里做了解释。

需要用typename告诉解析器这是个类型，否则编译器会当做相应的静态变量来处理。比如,C是一个模板类：

C::iterator* x;编译器会理解为是C的静态变量乘上x……