template模板详解第一集

软件	操作系统
visual stdio Code	win11

获取代码资源点击这里或加Q群：928357277一起学习，博主期待你们的到来

使用头文件: #include <iostream>

学习目录

模板用法1：变量初始化

template<typename T,T Tn>
class initZero
{
public:
    T a = T();//初始化会被清零
    T v = T(Tn);//初始化为Tn
};
//主函数使用
int main()
{
	initZero<int,16> x;
    std::cout<<x.v<<" x.a = "<<x.a<<std::endl;
    return  1；
}

模板用法2：模板函数的声明

//函数声明
template<typename T>
void mytest(T a = T(5));

//主函数使用
int main()
{
 	mytest<int>()//使用模板函数mytest
 	return  1；
}

//函数实体
template<typename S>
void mytest(S a){std::cout<<"a"<<a<<std::endl; };

模板用法3：用作类型的标识符

//1
class udef{
    public:
    class C{ int a =9;}; //嵌套一个类C
    using uint4 = int;
    int a = 0;
};
//2
template<typename T>
class mytepedef{
    public:
    typename T::C *p; 
    typename T::uint4 *uintp;
    T a;
};

//主函数使用
int main()
{
 	mytepedef<udef> str; //模板T被udef类替换,也就是声明了指针的作用域
    std::cout<<str.p<<'\n'<<str.uintp<<std::endl;//打印指针p,和指针uintp
 	return  1；
}

模板用法4：用作类型转换

template<typename T>
class Replace 
{
public:
    Replace(){std::cout<<"Replace"<<std::endl;};
    ~Replace(){std::cout<<"~~~~~~"<<std::endl;};
    template<typename T2>
    void replace(const Replace<T2>& r){this->a = r.aGet();}//替换类型，该模板构造方法也通常用于隐式类型转换，如果类型吻合，将会调用拷贝构造
    template<typename T3>
    Replace(const Replace<T3>& r){this->a = r.aGet(); }
    T aGet()const{ std::cout<< "P(a) = "<<&a<<std::endl; return a;} //重点：注意该方法，只有调用该方法，才能产生替换
private:
    T a;
};

//主函数使用
int main()
{
 	Replace<int> in;
    Replace<float> fl;
    //复制代码，打印可以看到这种情况，类型替换时候没有调用构造函数打印
    Replace<int> in3(fl);//类型不一致时候,调用模板构造进行初始化
    Replace<int> in4(in);//类型一致时调佣内建复制构造进行初始化
    in.replace(in);
 	return  1；
}

模板用法5：运算符重载和类友元函数


//类外模板函数声明，详细请读本文模本用法2
template<typename S>
void printMyOverLoad(S a = S(5));
template<typename S>
void printMyOverLoad(S a){std::cout<<a<<std::endl;}

//定义一个“重载”类
template<typename T>
class myOverLoad
{
public:
    myOverLoad (){};
    ~myOverLoad (){}; 
    template<typename T2>
    void operator=(const myOverLoad<T2>& t){this->a = t->a;} //重载 = 
    friend void printMyOverLoad<>(T a);;//友元函数
    void seta(const T& a){this->a = a;}//加载a 的值
    T geta()const{return a;}//得到a的值
private: //类的私有成员变量a
    T a;
};

//主函数使用
int main()
{
 	//模板调用重载
    myOverLoad<int> a; //创建a对象
    a.seta(23);//给a 对象赋值
    myOverLoad<int> b; //创建 b对象
    b.seta(55);//给 b 对象赋值
    a = b; //使用重载运算符 =
    printMyOverLoad(6);//调用友元函数
    std::cout<<a.geta()<<std::endl; //打印赋值后的a 对象的值
 	return  1；
}

模板用法6：抽象类的继承


template<typename T>
class People//抽象类“人”
{
public:
    virtual void setSex(const T& sex) = 0;//性别
    virtual void setAge(const T& age) = 0;//年龄
};

class Woman:public People<int> //类“女人”
{
public:
    Woman (){};
    ~Woman (){};
    void setSex(const int& s){this->sex = s;}//重写性别
    void setAge(const int& a){this->age = a;}//重写年龄
    void lookPeople(){std::cout<<"性别："<<sex<<"\n年龄："<<age<<std::endl;}
private:
    int age;//年龄
    int sex;//年龄
};

template<typename M>
class Man:public People<M> //类“男人”
{
public:
    Man (){};
    ~Man (){};
    void setSex(const M& s){this->sex = s;}//重写性别
    void setAge(const M& a){this->age = a;}//重写年龄
    void lookPeople(){std::cout<<"性别："<<sex<<"\n年龄："<<age<<std::endl;}
private:
    M age;//年龄
    M sex;//性别
};


//主函数使用
int main()
{
    Woman *woman = new Woman();//创建woman对象
    woman->setSex(0);//设置性别
    woman->setAge(21);//设置年龄
    woman->lookPeople();//观察woman
    Man<float> *man = new Man<float>();//创建man对象
    man->setAge(23.1f);
    man->setSex(1.2f);
    man->lookPeople();
 	return  1；
}