网站设计例子,wordpress 添加meta,wordpress essential ,莱芜1.模板
就是建立通用的模具#xff0c;大大提高复用性
模板的特点#xff1a; 模板不可以直接使用#xff0c;它只是一个框架 模板的通用并不是万能的 * C另一种编程思想称为 泛型编程 #xff0c;主要利用的技术就是模板 * C提供两种模板机制:**函数模板**和**类模板*…
1.模板
就是建立通用的模具大大提高复用性
模板的特点 模板不可以直接使用它只是一个框架 模板的通用并不是万能的 * C另一种编程思想称为 泛型编程 主要利用的技术就是模板 * C提供两种模板机制:**函数模板**和**类模板**
2函数模板
函数模板作用
建立一个通用函数其函数返回值类型和形参类型可以不具体制定用一个虚拟的类型来代表。
语法 templatetypename T
函数声明或定义 template --- 声明创建模板
typename --- 表面其后面的符号是一种数据类型可以用class代替
T --- 通用的数据类型名称可以替换通常为大写字母
//交换整型函数
void swapInt(int a, int b) {int temp a;a b;b temp;
}
//交换浮点型函数
void swapDouble(double a, double b) {double temp a;a b;b temp;
}
//利用模板提供通用的交换函数
templatetypename T
void mySwap(T a, T b)
{T temp a;a b;b temp;
}
void test01()
{int a 10;int b 20;//swapInt(a, b);//利用模板实现交换//1、自动类型推导mySwap(a, b);//2、显示指定类型
// mySwapint(a, b);cout a a endl;cout b b endl;
}
总结
* 函数模板利用关键字 template * 使用函数模板有两种方式自动类型推导、显示指定类型 * 模板的目的是为了提高复用性将类型参数化 注意事项 * 自动类型推导必须推导出一致的数据类型T,才可以使用 * 模板必须要确定出T的数据类型才可以使用 //利用模板提供通用的交换函数
templateclass T
void mySwap(T a, T b)
{T temp a;a b;b temp;
}
// 1、自动类型推导必须推导出一致的数据类型T,才可以使用
void test01()
{int a 10;int b 20;char c c;mySwap(a, b); // 正确可以推导出一致的T//mySwap(a, c); // 错误推导不出一致的T类型
}
// 2、模板必须要确定出T的数据类型才可以使用
templateclass T
void func()
{cout func 调用 endl;
}
void test02()
{//func(); //错误模板不能独立使用必须确定出T的类型funcdouble(); //利用显示指定类型的方式给T一个类型才可以使用该模板
} 3.普通函数和函数模版的区别
* 普通函数调用时可以发生自动类型转换隐式类型转换 * 函数模板调用时如果利用自动类型推导不会发生隐式类型转换 * 如果利用显示指定类型的方式可以发生隐式类型转换
#includeiostream
#includefstream
#includestring
using namespace std;
//普通函数
int myAdd01(int a, int b)
{return a b;
}
//函数模板
templateclass T
T myAdd02(T a, T b)
{return a b;
}
//使用函数模板时如果用自动类型推导不会发生自动类型转换,即隐式类型转换
void test01()
{int a 10;int b 20;char c c;cout myAdd01(a, c) endl; //正确将char类型的c隐式转换为int类型 c 对应 ASCII码 99//myAdd02(a, c); // 报错使用自动类型推导时不会发生隐式类型转换myAdd02int(a, c); //正确如果用显示指定类型可以发生隐式类型转换
}
int main() {test01();return 0;
}
4.普通函数和函数模板的调用规则
调用规则如下
1. 如果函数模板和普通函数都可以实现优先调用普通函数 2. 可以通过空模板参数列表来强制调用函数模板 3. 函数模板也可以发生重载 4. 如果函数模板可以产生更好的匹配,优先调用函数模板 //普通函数与函数模板调用规则
void myPrint(int a, int b)
{cout 调用的普通函数 endl;
}templatetypename T
void myPrint(T a, T b)
{ cout 调用的模板 endl;
}templatetypename T
void myPrint(T a, T b, T c)
{ cout 调用重载的模板 endl;
}void test01()
{//1、如果函数模板和普通函数都可以实现优先调用普通函数// 注意 如果告诉编译器 普通函数是有的但只是声明没有实现或者不在当前文件内实现就会报错找不到int a 10;int b 20;myPrint(a, b); //调用普通函数//2、可以通过空模板参数列表来强制调用函数模板myPrint(a, b); //调用函数模板//3、函数模板也可以发生重载int c 30;myPrint(a, b, c); //调用重载的函数模板//4、 如果函数模板可以产生更好的匹配,优先调用函数模板char c1 a;char c2 b;myPrint(c1, c2); //调用函数模板
}int main() {test01();system(pause);return 0;
}
总结既然提供了函数模板最好就不要提供普通函数否则容易出现二义性
5.函数模版的局限性
**例如**
C templateclass T void f(T a, T b) { a b; }
在上述代码中提供的赋值操作如果传入的a和b是一个数组就无法实现了 再例如
C templateclass T void f(T a, T b) { if(a b) { ... } }
在上述代码中如果T的数据类型传入的是像Person这样的自定义数据类型也无法正常运行
因此C为了解决这种问题提供模板的重载可以为这些**特定的类型**提供**具体化的模板** #includeiostream
using namespace std;
#include string
class Person
{
public:Person(string name, int age){this-m_Name name;this-m_Age age;}string m_Name;int m_Age;
};
//普通函数模板
templateclass T
bool myCompare(T a, T b)
{if (a b){return true;}else{return false;}
}
//具体化显示具体函数模板以template开头并通过名称来指出类型
//具体化优先于常规模板
template bool myCompare(Person p1, Person p2)
{if ( p1.m_Name p2.m_Name p1.m_Age p2.m_Age){return true;}else{return false;}
}
void test01()
{int a 10;int b 20;//内置数据类型可以直接使用通用的函数模板bool ret myCompare(a, b);if (ret){cout a b endl;}else{cout a ! b endl;}
}void test02()
{Person p1(Tom, 10);Person p2(Tom, 10);//自定义数据类型不会调用普通的函数模板//可以创建具体化的Person数据类型的模板用于特殊处理这个类型bool ret myCompare(p1, p2);if (ret){cout p1 p2 endl;}else{cout p1 ! p2 endl;}
}int main() {test01();test02();return 0;
} 利用具体化的模板可以解决自定义类型的通用化 学习模板并不是为了写模板而是在STL能够运用系统提供的模板
6.类模板
类模板作用
* 建立一个通用类类中的成员 数据类型可以不具体制定用一个**虚拟的类型**来代表 语法 templatetypename T 类 template --- 声明创建模板
typename --- 表面其后面的符号是一种数据类型可以用class代替
T --- 通用的数据类型名称可以替换通常为大写字母
#includeiostream
using namespace std;
#include string
// 类模板
templateclass NameType,class AgeType
class Person{
public:Person(NameType name,AgeType age){this-m_Name name;this-m_Age age;}void showPerson(){coutname:this-m_Name age:this-m_Ageendl;}NameType m_Name;AgeType m_Age;
};int main() {
// 指定Nametype为intAgetype为stringPersonint,string p1(10,Tom);p1.showPerson();return 0;
}
总结类模板和函数模板语法相似在声明模板template后面加类此类称为类模板 类模板与函数模板区别
类模板与函数模板区别主要有两点
1. 类模板没有自动类型推导的使用方式 2. 类模板在模板参数列表中可以有默认参数
//类模板
templateclass NameType, class AgeType int //1、类模板没有自动类型推导的使用方式
void test01()
{// Person p(孙悟空, 1000); // 错误 类模板使用时候不可以用自动类型推导Person string ,intp(孙悟空, 1000); //必须使用显示指定类型的方式使用类模板p.showPerson();
}//2、类模板在模板参数列表中可以有默认参数
void test02()
{Person string p(猪八戒, 999); //类模板中的模板参数列表 可以指定默认参数p.showPerson();
}
但是我发现这东西就像占位参数一样只要有一个默认参数之后所有的参数都必须有默认参数。
#includeiostream
using namespace std;
#include string
// 类模板
templateclass AgeType int,class NameTypestring
class Person{
public:Person(NameType name,AgeType age){this-m_Name name;this-m_Age age;}void showPerson(){coutname:this-m_Name age:this-m_Ageendl;}NameType m_Name;AgeType m_Age;
};int main() {
// 指定Nametype为intAgetype为stringPerson p1(Tom,20);p1.showPerson();return 0;
}
类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数创建时机是有区别的
* 普通类中的成员函数一开始就可以创建 * 类模板中的成员函数在调用时才创建
#includeiostream
using namespace std;
#include string
class Person1{
public:void showPerson1(){cout Person1 show endl;}
};
class Person2{
public:void showPerson2(){cout Person2 show endl;}
};
templateclass T
class MyClass{
public:T obj;
// 类模板中的成员函数并不是一开始就创建的而是在调用的时候才去创建的。void fun1(){obj.showPerson1();}void fun2(){obj.showPerson2();}
};
int main() {MyClassPerson1 m;m.fun1();
// m.fun2(); 编译会报错了说明函数调用才会去创建成员函数。return 0;
}
类模板对象做函数参数
一共有三种传入方式
1. 指定传入的类型 --- 直接显示对象的数据类型 2. 参数模板化 --- 将对象中的参数变为模板进行传递 3. 整个类模板化 --- 将这个对象类型 模板化进行传递 #includeiostream
using namespace std;
#include string
//类模板
templateclass NameType,class AgeTypeint
class Person{
public:Person(NameType name,AgeType age){this-m_Name name;this-m_Age age;}void showPerson(){coutname:this-m_Name age:this-m_Ageendl;}NameType m_Name;AgeType m_Age;
};
// 1.指定传入类型
void printPerson1(Personstring,int p){p.showPerson();
}
//2.参数模板化
templateclass T1,class T2
void printPerson2(PersonT1,T2 p){p.showPerson();coutT1的类型为typeid(T1).name()endl;coutT2的类型为typeid(T2).name()endl;
}
//3.整个类模板化
templateclass T
void printPerson3(T p){p.showPerson();coutT的类型为typeid(T).name()endl;
}
int main() {Personstring,int p1(Tom,20);printPerson1(p1);Personstring,int p2(Jerry,30);printPerson2(p2);Personstring,int p3(David,40);printPerson3(p3);return 0;
}
类模板与继承
当类模板碰到继承时需要注意一下几点
* 当子类继承的父类是一个类模板时子类在声明的时候要指定出父类中T的类型 * 如果不指定编译器无法给子类分配内存 * 如果想灵活指定出父类中T的类型子类也需变为类模板
#includeiostream
using namespace std;
#include string
templateclass T
class Base{T m;
};
// 子类继承类模板必须为父类模板指定类型否则编译器无法给子类分配内存
class Son :public Baseint{};
// 类模板继承类模板可以用T1或T2指定父类模板的类型
templateclass T1,class T2
class Son2:public BaseT1{
public:Son2(){coutT1的类型为typeid(T1).name()endl;coutT2的类型为typeid(T2).name()endl;}
};
int main() {Son c;Son2int,string c2;return 0;
}
如果父类是类模板子类需要指定出父类中T的数据类型
类模板成员函数类外实现
#includeiostream
using namespace std;
#include string
templateclass T1,class T2
class Person{
public:
// 成员函数类内声明Person(T1 name,T2 age);void showPerson();T1 m_Name;T2 m_Age;
};
// 类外实现
templateclass T1,class T2
PersonT1,T2::Person(T1 name,T2 age){this-m_Name name;this-m_Age age;
}
// 类外实现
templateclass T1,class T2
void PersonT1,T2::showPerson(){coutname:this-m_Name age:this-m_Ageendl;
}
int main() {Personstring,int p(Tom,20);p.showPerson();return 0;
}
总结类模板中成员函数类外实现时需要加上模板参数列表
类模板分文件编写
回顾分文件编写
.h文件写声明
.cpp 文件写实现
#pragma once #防止头文件重复包含 类模板中成员函数创建时机是在调用阶段导致分文件编写时链接不到。
所以按照之前的写法会报错
解决办法
1.在main.cpp主函数中引入Person.cpp,而不是.h文件
2.将声明和实现写到同一个文件中并更改后缀名为.hpphpp是约定的名称并不是强制
#pragma once
#include iostream
using namespace std;
#include stringtemplateclass T1, class T2
class Person {
public:Person(T1 name, T2 age);void showPerson();
public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
templateclass T1, class T2
PersonT1, T2::Person(T1 name, T2 age) {this-m_Name name;this-m_Age age;
}//成员函数 类外实现
templateclass T1, class T2
void PersonT1, T2::showPerson() {cout 姓名: this-m_Name 年龄: this-m_Age endl;
}
#includeiostream
using namespace std;//#include person.h
#include person.cpp //解决方式1包含cpp源文件//解决方式2将声明和实现写到一起文件后缀名改为.hpp
#include person.hpp
void test01()
{Personstring, int p(Tom, 10);p.showPerson();
}int main() {test01();system(pause);return 0;
}
总结主流的解决方式是第二种将类模板成员函数写到一起并将后缀名改为.hpp
类模板与友元
全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在
#includeiostream
using namespace std;
#include string//***********************************************
// 全局函数类外实现
templateclass T1,class T2
class Person;
templateclass T1,class T2
void printPerson2(PersonT1,T2 p){coutp.m_Name 类外实现 p.m_Ageendl;
}
//***********************************************templateclass T1,class T2
class Person{
// 1.全局函数配合友元 类内实现friend void printPerson(PersonT1,T2 p){coutp.m_Name p.m_Ageendl;}
// 2.全局函数配合友元 类外实现friend void printPerson2(PersonT1,T2 p);
public:Person(T1 name,T2 age){this-m_Name name;this-m_Age age;}
private:T1 m_Name;T2 m_Age;
};
int main() {Personstring,int p(Tom,20);printPerson2(p);return 0;
}
总结建议全局函数做类内实现用法简单而且编译器可以直接识别
