|
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
C++中有一个重要特性，那就是模板类型。类似于Objective-C中的泛型，C++通过类模板来实现泛型支持。它使用参数化的类型创建相应的函数和类，分别称之为函数模板和类模板。
模板是一种对类型进行参数化的工具，通常有两种形式：函数模板和类模板。函数模板针对仅参数类型不同的函数；类模板针对仅数据成员和成员函数类型不同的类，可以显著减小源代码的大小并提高代码的灵活性，而不会降低类型安全。
一、函数模板
定义：函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。
格式：template <class 类型参数1，class 类型参数2，…>
1.1一般模板函数
template<typename T>
int compare(const T& left, const T& right) {
if (left < right) {
return -1;
}
if (right < left) {
return 1;
}
return 0;
}
compare<int>(1, 2); //使用模板函数
1.2 特化模板函数
template<>
void func(int i) {
cout << "In special version for int "<< i << endl;
}
int i = 88;
func(i); //调用特化版本
1.3 C++模板的一些注意事项
1、模板的定义和声明最好不要放在不同地方
模板在定义时即使用，要像其他普通函数或类在.h中声明，.cpp中定义的话，很可能出现问题
2、模版不支持在局部函数中声明定义或使用。
3、模板非类型形参
模板除了定义类型参数，还可以在模板定义非类型参数。
二、模板类
2.1模板类
类模板以下面的这样的代码开头：
template <class T>
关键字template或class告诉编译器。将要定义一个模板，尖括号的内容相当于函数的参数列表。可以把关键字template或class看做是变量的类型名该变量接受类型作为其值，把T看做变量的名称。
如下，声明一个普通的类模板：
using namespace std;
template <typename T>
class Complex
{
public:
//构造函数
Complex(T a, T b)
{
this->a = a;
this->b = b;
}
//运算符重载
Complex<T> operator+(Complex& c)
{
Complex<T> tmp(this->a + c.a, this->b + c.b);
return tmp;
}
private:
T a;
T b;
};
int main()
{
//对象的定义，必须声明模板类型，因为要分配内容
Complex<int> a(10, 20);
Complex<int> b(20, 30);
Complex<int> c = a + b;
return 0;
}
类模板使用举例（Store)
using namespace std;
struct Student
{
int id;
double gpa;
};
template<class T> //模板声明，其中T为类型参数
class Store //类模板为Store
{
public:
Store();
T &getElem();
void putElem(const T &x);
private:
T item;
bool haveValue;
};
template<class T> //模板声明
Store<T>::Store() //在类模板体外定义成员函数push
{
haveValue=false;
}
template<class T>
T& Store<T>::getElem()
{
if (haveValue)
{
return item;
}
else
{
cout<<"ERROR!"<<endl;
exit(1);
}
}
template<class T> //模板声明
void Store<T>::putElem(const T &x) //在类模板体外定义成员函数PutElem
{
haveValue=true;
item=x;
}
int main()
{
//定义整型堆栈
Store<int> s1,s2; //用类模板定义对象s1,s2,此时T被int取待
s1.putElem(1);
s2.putElem(2);
cout<<s1.getElem()<<" "<<s2.getElem()<<endl;
Student a={1003,3.73};
Store<Student> s3;
s3.putElem(a);
cout<<s3.getElem().gpa<<endl;
system("Pause");
return 0;
}
2.2 模板类的继承
在模板类的继承中，需要注意以下几点：
如果父类自定义了构造函数，记得子类要使用构造函数列表来初始化
继承的时候，如果子类不是模板类，则必须指明当前的父类的类型，因为要分配内存空间
继承的时候，如果子类是模板类，要么指定父类的类型，要么用子类的泛型来指定父类
template <typename T>
class Parent{
public:
Parent(T p)
{
this->p = p;
}
private:
T p;
};
//如果子类不是模板类，需要指明父类的具体类型
class ChildOne:public Parent<int>{
public:
ChildOne(int a,int b):Parent(b)
{
this->cone = a;
}
private:
int cone;
};
//如果子类是模板类，可以用子类的泛型来表示父类
template <typename T>
class ChildTwo:public Parent<T>{
public:
ChildTwo(T a, T b):Parent<T>(b)
{
this->ctwo = a;
}
private:
T ctwo;
};
2.3 模板的特化
类模板的特化
有时为了需要,针对特定的类型,需要对模板进行特化,也就是特殊处理.例如,stack类模板针对bool类型,因为实际上bool类型只需要一个二进制位，就可以对其进行存储,使用一个字或者一个字节都是浪费存储空间的.
template <class T>
class stack {};
template < >
class stack<bool> { //…// };
上述定义中template < >告诉编译器这是一个特化的模板。
函数模板的特化
看下面的例子
main()
{
int highest = mymax(5,10);
char c = mymax(‘a’, ’z’);
const char* p1 = “hello”;
const char* p2 = “world”;
const char* p = mymax(p1,p2);
}
前面两个mymax都能返回正确的结果.而第三个却不能,因为,此时mymax直接比较两个指针p1 和 p2 而不是其指向的内容.
针对这种情况,当mymax函数的参数类型为const char* 时,需要特化。
template <class T>
T mymax(const T t1, const T t2)
{
return t1 < t2 ? t2 : t1;
}
template <>
const char* mymax(const char* t1,const char* t2)
{
return (strcmp(t1,t2) < 0) ? t2 : t1;
}
现在mymax(p1,p2)能够返回正确的结果了。
三、智能指针
3.1智能指针的作用
C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。
3.2智能指针的实质
智能指针是一个类对象，这样在被调函数执行完，程序过期时，对象将会被删除（对象的名字保存在栈变量中），这样不仅对象会被删除，它指向的内存也会被删除的。
3.3智能指针的分类和使用
智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、auto_ptr
建议：1-每种指针都有不同的使用范围，unique_ptr指针优于其它两种类型，除非对象需要共享时用shared_ptr。
2- 建议– 如果你没有打算在多个线程之间来共享资源的话，那么就请使用unique_ptr。
3 -建议- 使用make_shared而不是裸指针来初始化共享指针。
4 -建议 –
在设计类的时候，当不需要资源的所有权，而且你不想指定这个对象的生命周期时，可以考虑使用weak_ptr代替shared_ptr。
使用智能指针的时候，只需要将nes出的地址值赋值给这种对象，也就是将new出的地址作为实参！
|