class template

Posted on Edited on In , , Changyan: Symbols count in article: 4.2k Reading time ≈ 4 mins.

  • class Template

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    template<typename T>
    class complex
    {
        public:
        complex(T r=0;T i=0):re(r),im(i){}
        complex& operator +=(const complex&);
        T real()const{return re;}
        T imag()const{return im;}
        private:
        T re,im;
        friend complex& __doapl(complex*, const complex)
    }
    {
        complex<double> c1(2.5,1.4);
        complex<int> c2(2,6);
    }

  • 函数模板

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    template<class T> //class 可以换位typename
    inline
    const T& min(const T&a,const T&b){
        return b<a ? b:a;
    }

    * 成员模板

    ```cpp
    template <class T1,class T2>
    struct pair{
        ...
        T1 first;
        T2 second;
        pair():first(T1()),second(T2()){}
        pair(const T1& a,const T2& b):first(a),second(b){}

        template <class U1,class U2>
        pair(const pair<U1,U2>& p):first(p.first),second(p.second){}
    }

    <!-- more -->
    # class Template
    ```cpp
    template<typename T>
    class complex
    {
        public:
        complex(T r=0;T i=0):re(r),im(i){}
        complex& operator +=(const complex&);
        T real()const{return re;}
        T imag()const{return im;}
        private:
        T re,im;
        friend complex& __doapl(complex*, const complex)
    }
    {
        complex<double> c1(2.5,1.4);
        complex<int> c2(2,6);
    }

function Template

函数模板不用指明类型

1
2
3
4
5
6
7
8
template<class T> //class 可以换位typename
inline
const T& min(const T&a,const T&b){
    return b<a ? b:a;
}


// 如果是类对象要看对象是否重载了操作符<

成员模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
template <class T1,class T2>
struct pair{
    ...
    T1 first;
    T2 second;
    pair():first(T1()),second(T2()){}
    pair(const T1& a,const T2& b):first(a),second(b){}

    template <class U1,class U2>
    pair(const pair<U1,U2>& p):first(p.first),second(p.second){}
}

class Base1{};
class Derived1:public Base1{};

class Base2{};
class Dervied2:public Base2{};

//    T1   ,T2             U1     ,  U2
pair<Base1,Base2> p2(pair<Dervied1,Derived2>());

例子

1
2
3
4
5
6
7
8
9
template <typename>
class shared_prt:public __share_ptr<_Tp>{
    ...
    template<typename _Tp1>
    explicit shared_ptr(_Tp1 __p):__shared_ptr<_Tp>(__p){}
}

Base1* prt=new Derived; // up-cast
shared_ptr<Base1> sptr(new Derived1);// 模拟 up-cast

特化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
template <class Key>
struct has{}

template<>
struct hash<char>{
    size_t operator()(char x)const {return x;}
};

template<>
struct hash<int>{
    size_t operator()(int x)const {return x;}
};

template<>
struct hash<long>{
    size_t operator()(long x)const {return x;}
}

偏特化

  • 个数的偏特化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //从左向右特化，个数的特化，只有一个模板参数
    template <typename T,typename Alloc=...>
    class Vector{

    }

    template <typename Alloc=...>
    class vector<bool,Alloc>{

    }

  • 范围上的偏

1
2
3
4
5
6
7
8
9
10
11
12
template <typename T>
class C{

}
//指定是指针
template <typename T>
class C<T*>{

}

C<string> obj1;
C<string*> obj2;

模板模板参数（template template parameter）

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<template T ,template<typename T> class Container> //template<template T ,template<class T> class Container> 
class XCls{
    private:
        Container<T> c; //用第一个模板参数做参数
    public:
        ....;
}

template<typename T>
using Lst = list<T,allocator<T>>;//别名

XCls<string, list> mylst1;//Error 默认模板的第二参数，

XCls<string, Lst> mylst1;//

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
template<template T ,template<typename T> class SmartPtr> //template<template T ,template<class T> class Container> 
class XCls{
    private:
        SmartPtr<T> c; //用第一个模板参数做参数
    public:
        XCls():sp(new T){}
}

template<typename T>
using Lst = list<T,allocator<T>>;//别名

XCls<string, list> mylst1;//Error 默认模板的第二参数，

XCls<string, Lst> mylst1;//

XCls<string,shared_ptr> p1;
XCls<double,unique_ptr> p2; // Error
XCls<int,weak_ptr> p3;// Error
XCls<int,auto_ptr> p4;

是否是模板模板参数

1
2
3
4
5
6
7
8
9
10
11
12
template <class T,class Sequence = deque<T>>
class stack{
    friend bool operator == <> (const stack&,const stack)
    friend bool operator < <> (const stack&,const stack)

    protect:
    Sequence c;
}


stack<int> s1;
stack<int,list<int>> s2; //没有模糊的地带了，是确定的。因此不是模板模板参数