提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录- 前言
- 一、函数模板
- 1.1一般模板函数
- 1.2 特化模板函数
- 1.3 C++模板的一些注意事项
- 二、模板类
- 2.1模板类
- 类模板使用举例（Store)
- 2.2 模板类的继承
- 2.3 模板的特化
- 类模板的特化
- 函数模板的特化
- 三、智能指针
- 3.1智能指针的作用
- 3.2智能指针的实质
- 3.3智能指针的分类和使用
前言
C++中有一个重要特性，那就是模板类型。类似于Objective-C中的泛型，C++通过类模板来实现泛型支持。它使用参数化的类型创建相应的函数和类，分别称之为函数模板和类模板。
模板是一种对类型进行参数化的工具，通常有两种形式：函数模板和类模板。函数模板针对仅参数类型不同的函数；类模板针对仅数据成员和成员函数类型不同的类，可以显著减小源代码的大小并提高代码的灵活性，而不会降低类型安全。
一、函数模板定义：函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。
格式：template
template1.2 特化模板函数int compare(const T& left, const T& right) { if (left < right) { return -1; } if (right < left) { return 1; } return 0; } compare (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、模板非类型形参
模板除了定义类型参数，还可以在模板定义非类型参数。
类模板以下面的这样的代码开头：
template
关键字template或class告诉编译器。将要定义一个模板，尖括号的内容相当于函数的参数列表。可以把关键字template或class看做是变量的类型名该变量接受类型作为其值，把T看做变量的名称。
如下，声明一个普通的类模板：
#include类模板使用举例（Store)using namespace std; template class Complex { public: //构造函数 Complex(T a, T b) { this->a = a; this->b = b; } //运算符重载 Complex operator+(Complex& c) { Complex tmp(this->a + c.a, this->b + c.b); return tmp; } private: T a; T b; }; int main() { //对象的定义，必须声明模板类型，因为要分配内容 Complex a(10, 20); Complex b(20, 30); Complex c = a + b; return 0; }
#include "stdafx.h"
using namespace std;
struct Student
{
int id;
double gpa;
};
template //模板声明，其中T为类型参数
class Store //类模板为Store
{
public:
Store();
T &getElem();
void putElem(const T &x);
private:
T item;
bool havevalue;
};
template //模板声明
Store::Store() //在类模板体外定义成员函数push
{
havevalue=false;
}
template
T& Store::getElem()
{
if (havevalue)
{
return item;
}
else
{
cout<<"ERROR!"< //模板声明
void Store::putElem(const T &x) //在类模板体外定义成员函数PutElem
{
havevalue=true;
item=x;
}
int main()
{
//定义整型堆栈
Store s1,s2; //用类模板定义对象s1,s2,此时T被int取待
s1.putElem(1);
s2.putElem(2);
cout< s3;
s3.putElem(a);
cout<
2.2 模板类的继承
在模板类的继承中，需要注意以下几点：
如果父类自定义了构造函数，记得子类要使用构造函数列表来初始化
继承的时候，如果子类不是模板类，则必须指明当前的父类的类型，因为要分配内存空间
继承的时候，如果子类是模板类，要么指定父类的类型，要么用子类的泛型来指定父类
template
class Parent{
public:
Parent(T p)
{
this->p = p;
}
private:
T p;
};
//如果子类不是模板类，需要指明父类的具体类型
class ChildOne:public Parent{
public:
ChildOne(int a,int b):Parent(b)
{
this->cone = a;
}
private:
int cone;
};
//如果子类是模板类，可以用子类的泛型来表示父类
template
class ChildTwo:public Parent{
public:
ChildTwo(T a, T b):Parent(b)
{
this->ctwo = a;
}
private:
T ctwo;
};
2.3 模板的特化
类模板的特化
有时为了需要,针对特定的类型,需要对模板进行特化,也就是特殊处理.例如,stack类模板针对bool类型,因为实际上bool类型只需要一个二进制位，就可以对其进行存储,使用一个字或者一个字节都是浪费存储空间的.
template
class stack {};
template < >
class stack { //…// };
上述定义中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
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出的地址作为实参！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）