接上一篇继续学习抽象类、函数模板
抽象类
c++中的抽象类是通过纯虚函数体现的,凡是含有纯虚函数的类叫做抽象类
纯虚函数:是一种特殊的虚函数，在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。
它的一般格式如下：
class <类名>{
virtual <类型><函数名>(<参数表>)=0;
…
};
抽象类是不能直接创建的，如果子类没有实现所有的纯虚函数，则这个派生类也是抽象类。
#include <iostream>
#include <string.h>
#include <unistd.h>
using namespace std;
class Human {
private:
int a;
public:
virtual void eating(void) = 0;
virtual void wearing(void) = 0;
virtual void driving(void) = 0;
virtual ~Human() { cout<<"~Human()"<<endl; }
virtual Human* test(void) {cout<<"Human's test"<<endl; return this; }
};
class Englishman : public Human {
public:
void eating(void) { cout<<"use knife to eat"<<endl; }
void wearing(void) {cout<<"wear english style"<<endl; }
void driving(void) {cout<<"drive english car"<<endl; }
virtual ~Englishman() { cout<<"~Englishman()"<<endl; }
virtual Englishman* test(void) {cout<<"Englishman's test"<<endl; return this; }
};
class Chinese : public Human {
public:
void eating(void) { cout<<"use chopsticks to eat"<<endl; }
void wearing(void) {cout<<"wear chinese style"<<endl; }
void driving(void) {cout<<"drive chinese car"<<endl; }
virtual ~Chinese() { cout<<"~Chinese()"<<endl; }
virtual Chinese* test(void) {cout<<"Chinese's test"<<endl; return this; }
};
int main(int argc, char **argv){
//Human h; //抽象类不能直接创建
Englishman e;
Chinese c;
return 0;
}
抽象类主要的作用是进行类型隐藏。构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。
函数模板
函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。类似java中的泛型。
函数模板定义的一般形式如下：
template<类型形式参数表>
返回类型 函数名(形式参数表){
... //函数体
}
使用模板实现返回2个数中大值函数
#include <iostream>
#include <string.h>
#include <unistd.h>
using namespace std;
template<typename T>
T& mymax(T& a, T& b){
cout<<__PRETTY_FUNCTION__<<endl;
return (a < b)? b : a;
}
int main(int argc, char **argv){
int ia = 1, ib = 2;
float fa = 1, fb = 2;
double da = 1, db = 2;
mymax(ia, ib);
mymax(fa, fb);
mymax(da, db);
return 0;
}
cout<<PRETTY_FUNCTION<<endl;可以打印方法名称
输出：
T& mymax(T&, T&) [with T = int]
T& mymax(T&, T&) [with T = float]
T& mymax(T&, T&) [with T = double]
- 函数模板的原理：
- 函数模板只是编译指令，一般写在头文件中；
- 编译程序时，编译器根据函数的参数来“推导”模板的参数；然后生成具体的模板函数
示例代码：
int a; int b; mymax(a, b);
编译器根据函数参数a,b推导出模板参数为int，所以把模板中的T绑定为int；
编译程序时生成如下函数：
int& mymax(int& a, int& b){
return (a<b)?b:a;
}
所以在上面的main函数中有int、float、double三种类型的模板函数。
mymax(ia, ib);
mymax(fa, fb);
mymax(da, db);
这三个的调用其实调用了三个模板函数
模板的参数推导支持的类型转换比较少，主要有两种：
- const转换 ：函数参数为非const引用/指针, 它可以隐式转换为const引用/指针
template<typename T>
const T& mymax(const T& a, const T& b){
cout<<__PRETTY_FUNCTION__<<endl;
return (a < b)? b : a;
}
int main(int argc, char **argv){
int ia = 1;
int ib = 2;
mymax(ia, ib);
return 0;
}
推导的结果:const T& mymax(const T&, const T&) [with T = int]
- 数组或函数指针转换:
- 1.数组可以隐式转换为“指向第1个元素的指针”
- 2.参数为“函数的名字” 时，它隐式转换为“函数指针”
template<typename T>
const T& mymax(const T& a, const T& b){
cout<<__PRETTY_FUNCTION__<<endl;
return (a < b)? b : a;
}
template<typename T>
const T* mymax2(const T* a, const T* b){
cout<<__PRETTY_FUNCTION__<<endl;
return (a < b)? b : a;
}
template<typename T>
void test_func(T f){
cout<<__PRETTY_FUNCTION__<<endl;
}
int f1(int a, int b){
return 0;
}
int main(int argc, char **argv){
char a[]="ab";
char b[]="cd";
mymax(a, b); /* T=char[3] */
mymax2(a, b);
char a2[]="abc";
char b2[]="cd";
//mymax(a2, b2); /* mymax(char[4], char[3]), 无法推导出T: mymax(char& [4], char& [3]), 因为两个参数类型不一样 */
mymax2(a2, b2); /* mymax2(char[4], char[3]), 推导: mymax2(const char *, const char *); */
test_func(f1);
test_func(&f1);
return 0;
}
输出：
const T& mymax(const T&, const T&) [with T = char [3]]
const T* mymax2(const T*, const T*) [with T = char]
const T* mymax2(const T*, const T*) [with T = char]
void test_func(T) [with T = int (*)(int, int)]
void test_func(T) [with T = int (*)(int, int)]
mymax2模板可以将数组转换为指针，所以char数组的长度不同也会推导出来是 char*,而如果是引用则会因为推导出char& [4], char& [3]不一样的类型，推导失败。
对于传入的参数是函数，不论是函数名还是引用，都会被转为函数指针。
