一、智能指针

举个栗子:
看下面代码, 当我们直接new一个指针时, 忘记delete了, 那么会造成内存泄漏,我们必须手动的去delete指针
但是当我们使用智能指针的时候, 我们不去delete的时候,它会自动调用析构函数去销毁指针, 类似于java中的垃圾回收机制

#include<iostream>
#include<memory>
using namespace std;class Test
{public:Test(){cout<<"Test的构造函数"<<endl;}void print(){cout<<"xxx"<<endl;}~Test(){cout<<"Test的析构函数"<<endl;}
};void f1()
{Test* t1 = new Test;
}void f2()
{auto_ptr<Test> my_memory(new Test);my_memory->print();
}int main()
{f1();f2();return 0;
}result:
Test的构造函数
Test的构造函数
xxx
Test的析构函数

二、模板

1. 概念

将函数的返回值和参数的类型 参数化, 也称为泛型编程

2.函数模板

C++提供了一套机制,建立一个通用函数,其函数参数的类型和返回值类型不具体指定,用一个虚拟的类型来代替

#include<iostream>
using namespace std;/*
int add(int x, int y)
{return x + y;
}double add(double x, double y)
{return x + y;
}
虽然在C++中我们可以使用函数重载，如上：通过传参类型不同，调用对应的同名接口
但是问题是，我们还是需要将这个功能函数实现两遍
*///所以衍生出了模板
template <typename T>   //声明虚拟类型T，我们传什么，它就是什么
T add(T x, T y)
{return x + y;
}template <typename T1, typename T2>//模板T的作用域只到它的下一个函数结束
void show(T1 x, T2 y)
{cout<< x<<" " <<y<<endl;
}int main()
{cout <<add(1,2)<<endl;        //隐式调用cout <<add(1.11,2.22)<<endl;cout <<add<int>(1,'a')<<endl; //显式调用show(1,'a');show<double, char>(1.11, 'a'); //显示调用return 0;
}result:
3
3.33
98
1 a
1.11 a

1. 函数模板和普通函数

当普通函数和模板函数同时出现时, 优先使用普通函数
普通函数可以进行默认类型转化
模板函数没有默认的类型转换

#include<iostream>
using namespace std;int add(int x, int y)
{cout<<"普通函数"<<endl;return x + y;
}double add(double x, double y)
{return x + y;
}template <typename T>   //声明虚拟类型T，我们传什么，它就是什么
T add(T x, T y)
{cout<<"模板函数"<<endl;return x + y;
}template <typename T1, typename T2>//模板T的作用域只到它的下一个函数结束
void show(T1 x, T2 y)
{cout<< x<<" " <<y<<endl;
}int main()
{cout <<add(1,2)<<endl;        //当普通函数和模板函数同时出现时, 优先使用普通函数cout <<add<int>(1,'a')<<endl; //只有模板函数才有显式调用, 模板函数没有默认的类型转换cout <<add(1,'a')<<endl;      //普通函数可以进行默认类型转化//show(1,'a');//show<double, char>(1.11, 'a'); //显示调用return 0;
}

3. 类模板

1.类模板的定义

类模板中定义的函数类型可以用在类声明和类实现中
类模板的目的同样是将数据类型参数化
并且在实例化对象的时候,一定要显式调用

2.举个例子

#include<iostream>
using namespace std;template<typename T, typename U>
class Test
{private:T a;U b;public:Test(T a, U b){this->a = a;this->b = b;}void show(){cout<<a << " "<< b <<endl;}
};int main()
{Test<int, char> t(1, 'a');//类模板创建对象，一定要显式调用t.show();return 0;
}

3.举例

#include<iostream>
using namespace std;template <typename T, typename U>
class Parent
{protected:T a;U b;public:Parent(T a, U b){this->a = a;this->b = b;}void show(){cout<<a << " "<< b <<endl;}
};class Child:public Parent<int, char> //模板类派生普通类，继承时，要对基类实例化,显示继承
{public:Child(int a, char b): Parent(a, b){}void show(){cout<<a<<" "<<b<<endl;}
};template<typename T, typename U>
class Child2:public Parent<T, U> //模板类派生模板类，继承的同时，不需要对基类实例化
{private:U c;public:Child2(T a, U b, U c): Parent<T, U>(a, b){this->c = c;}void show(){cout<<this->a<<" "<<this->b<<" "<<this->c<<endl;}
};int main()
{Child c1(1, 'a');c1.show();Child2<int, double> c2(1,1.11,2.22);c2.show();return 0;
}