深入理解模板2

1,typename关键字:
(1)若一个模板代码内部的某个类型被模板参数所限定,则必须使用typename关键字作为前缀声明.
注:typename关键字仅仅用于模板代码中.
(2)一定不能认为typename创建了一个新类型名.
typename Seq<T>::iterator ite;
typedef typename Seq<T>::iterator ite;//这才是创建一个新类型名.
实例代码:

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

class SkipGen
{
    int start,step;
public:
    SkipGen(int m=1,int n=3):start(m),step(n){}
    int operator()()
    {
        int temp=start;
        start+=step;
        return temp;
    }
};

template<class T,template<class U,class=allocator<U> > class Seq>
void printSeq(const Seq<T>& seq) //const对应const
{
    typename Seq<T>::const_iterator ite;
    for(ite=seq.begin();ite!=seq.end();ite++)
    {
        if(ite==seq.begin())
            cout<<*ite;
        else
            cout<<" "<<*ite;
    }
    cout<<endl;
}

int main()
{
    vector<int> vec(10);
    generate(vec.begin(),vec.end(),SkipGen(1,3));
    printSeq(vec);

    list<int> lst(10);
    generate(lst.begin(),lst.end(),SkipGen(2,2));
    printSeq(lst);

    return 0;
}

2,template关键字:
"<"有时候代表小于号,template告诉编译器紧接着的是一个模板名称.
实例代码:

#include <iostream>
#include <bitset>
#include <cstddef>
using namespace std;

template<class charT,size_t N>
basic_string<charT> bitSetString(bitset<N> bs)
{
    //这里必须使用template解析.
    return bs.template to_string<charT,char_traits<charT>,allocator<charT> >();
}
//注:to_string本身就是一个模板函数,但是没有使用默认参数.
//basic_string使用了默认参数
//这样就可以用bitSetString<char>(bs)替代bs. template to_string<char,char_traits<char>,allocator<char> >()
int main()
{
    bitset<10> bs;
    bs.set(1),bs.set(5);
    cout<<bs<<endl;

    string str1=bitSetString<char>(bs);
    cout<<str1<<endl;

    string str2=bs.to_string<char,char_traits<char>,allocator<char> >();
    cout<<str2<<endl;
    return 0;
}

3,模板类的成员是模板类.
注:成员模板函数不能被声明为virtual类,这是因为编译器解析一个类时,需要知道虚函数表的大小,如果允许模板虚成员函数,则必须提前知道这些模板成员在哪里调用.
实例代码:

#include <iostream>
using namespace std;

template<class T>
class Outer
{
public:
    template<class U>
    class Inner
    {
    public:
        void f();
    };
};

template<class T>
template<class U>
void Outer<T>::Inner<U>::f()
{
    cout<<"Outer type=="<<typeid(T).name()<<endl;
    cout<<"Inner type=="<<typeid(U).name()<<endl;
    cout<<"class Inner=="<<typeid(*this).name()<<endl;
}

int main()
{
    Outer<int>::Inner<bool> inner;
    inner.f();
    return 0;
}