笔记_类模板成员函数_typename_模板_类模板_可变参类模板_using

类模板成员函数

可以写在类模板定义中{}。那么这种写在类模板定义中的成员函数会被隐式声明为inline函数。
一个实例化模板，它的成员函数只有在使用时才会被实例化

注意，浮点型不能做非类型模板参数

template<class T>
class FVector
{
public:
    FVector();
    typedef T* FIterator;
    FVector& operator=(const FVector&);
private:
    FIterator FBegin();
    FIterator FEnd();
};
template <class T>
FVector<T>& FVector<T>::operator=(const FVector&)
{
    return *this;
}
template<class T>
FVector<T>::FVector()
{    
}
template <class T>
typename FVector<T>::FIterator FVector<T>::FBegin()
{
}
int main()
{
    FVector<int> myvector;
    return 0;
}

typename 目的是为了显式告诉编译器 FVector 是一个类型
用法2

template<class T>
typename T::size_type getlegth(const T &cc)
{
    if (!cc.empty())
    {
        return cc.size();
    }
    return 0;
}
//函数指针当做参数传递
using funInt = int(*)(int, int);
int mf(int a, int b)
{
    return a+b;
}
int ref(int a,int b,funInt ff)
{
    return ff(a, b);
}
main: cout<<ref(2, 5, mf)<<endl;

模板写法

template <typename  T,typename F>
void ttt(const T& a,const T& b,F fun)
{
    cout<< fun(a,b)<<endl;
}

同时给模板参数和函数参数提供缺省值

class Test;
template <typename  T,typename F = Test>
int ttt(const T& a,const T& b,F fun = F())
{
    return fun(a, b);
}
class Test
{
public:
    Test() {};
    int operator()(int a,int b)
    {
        if (a>b)
        {
            return a;
        }
        else
        {
            return b;
        }
    }
};
int main()
{

    int er = ttt(49, 5);
    return 0;
}

普通类的成员函数模板
成员函数模板不可以是虚函数，否则会报错

类模板的成员函数模板

template<class T>
class Test2
{
public:
    template<class R>
    Test2(R a1,R a2)
    {
        
    }
};
main:Test2<int> tttt(5,7);

模板显式实例化

template <typename T>
class Tta
{
public:
    Tta() {  }
};
template Tta<int>;//实例化定义

using定义模板别名

template <typename T>
struct mys
{
    typedef map<string, T> type;
};
template <typename T>
using type =  map<string, T>;

类模板特化

泛化模板，可以随便指定类型
特化，对特殊类型进行特殊对待，写适合他的专用代码
只要存在特化，就一定存在泛化
全特化就是指的所有类型模板参数

template<typename  T,typename  U>
struct ct
{
    void funtest()
    {
        cout << "泛化版本" << endl;
    }
};
template<>//全特化
struct ct<int,int>
{
    void funtest()
    {
        cout << "int,int 全特化" << endl;
    }
};
//偏特化
template<typename  T,typename  U,typename F>
struct ct
{
    void funtest()
    {
        cout << "泛化版本" << endl;
    }
};

template<typename U>
struct ct<int,U,int>
{
    void funtest()
    {
        cout << "int,int 偏特化" << endl;
    }
};

//可变参数模板

template<typename ... T>
void fun6(T ... args)
{
    cout<< sizeof ...(args) <<endl;
}

T 后带了。。。 称呼T:可变参数类型
args 称为一包或者一堆参数，参数类型各不相同，可变形参

template<typename T,typename ...U>
void fun7(const T & d1,const U&...d3)
{
    cout << sizeof ...(d3) << endl;
}

可变参数包展开

void fun7()
{
    cout << "end" << endl;
}
template<typename T,typename ...U>
void fun7(const T & d1,const U&...d3)
{
    cout << "参数值："<<d1 << endl;
    fun7(d3...);
}
int main()
{
    fun7(12,"123",1,412,6436,123123,"cc");
    return 0;
}

可变参类模板（递归继承展开）

template<typename ... B>
class Ta1{};//主模板
template<typename A,typename ... B>
class Ta1<A,B...>:private Ta1<B...>
{
public:
    Ta1():m1(0)
    {
        printf("this:%p \n",this);
    }
    A m1;
};
void funcc()
{
    Ta1<int, float, double, int>mm;
}

可变参类模板（递归组合展开）

template<typename ...B>
class funcdemo
{
};
template<>
class funcdemo<>
{
    
};
template<typename A, typename ...B>
class funcdemo<A,B...>
{
public:
    funcdemo():a(0)
    {
        cout << "111" << endl;
    }
    funcdemo(A a_f,B...b_f):a(a_f),m_o(b_f)
    {
        
    }
    A a;
    funcdemo<B...> m_o;
};
void funcc()
{
    funcdemo<int, float, double> mm;
}

模板模板参数

template<
	typename T,
	template<class>class U //模板 模板参数
	//template<typename C>typename W //模板 模板参数,同上，仅写法不同 C只是占位
>
class myc
{
public:
    myc()
    {
        for (int i=0;i<10;i++)
        {
            myc1.push_back(it+i);
        }
    }
public:
    T it;
    U<T> myc1;//U作为类模板使用
    //W<T> myc2;
};
template<typename  T>
using mvector = vector<T, allocator<T>>;
void fun111()
{
    myc<int, mvector> myVector;
}
int main()
{
    fun111();
    return 0;
}