适合具备 C 语言基础的 C++ 教程（十）

前言

在上一则教程中，叙述了抽象类以及动态链接库的相关内容，本节来叙述一下抽象类界面的相关内容，以及本节即将引入一个新的概念，模板。

抽象类界面

何为抽象类界面呢？要说清楚这个概念，需要回顾上一则教程中所述的类编程和应用编程两个概念，为了实现应用编程和类编程，引入了动态链接库的概念，要达到的效果就是当更改类的代码的时候，而不更改应用程序的代码的时候，只需要重新生成动态链接库，而不需要重新生成可执行文件。那么我们回顾之前的代码，看应用编程里面的内容，也就是主函数里面的内容：

#include "Human.h"
#include "Englishman.h"
#include "Chinese.h"

void test_eating(Human *h)
{
    h->eating();
}


int main(int argc, char **argv)
{
    Englishman e;
    Chinese c;

    Human* h[2] = {&e, &c};
    int i;
    for (i = 0; i < 2; i++)
        test_eating(h[i]);

    return 0;
}

在上述代码中，我们看到第一行代码和第二行代码包含了头文件Englishman.h和 Chinese.h，那么这个时候，如果更改了类中代码，比如说我们更改了Englishman.h或者是Chinese.h的代码，这个时候在编译的时候，如果只编译动态链接库，而不编译应用程序，那么必然会导致程序出现问题。那要如何解决这个问题呢，所采取的一种思路便是使用抽象类界面的思路来进行解决。

下面是抽象类界面的一个示意图：

image-20210224101410895

通过这张示意图也可以明白，这个时候，APP也就是应用程序的代码只和Human.h相关，而 Human.h又和Englishman和Chinese有关，这样一来，如果改变的是Englishman或者是Chinese类的代码，那么就不会影响到应用程序，仍然只需要重新编译动态链接库就好。

说了那么多，该如何做呢，我们先从主函数看起，下面是更改之后的主函数：

#include "Human.h"

void test_eating(Human *h)
{
    h->eating();
}


int main(int argc, char **argv)
{
    Human& e = CreateEnglishman("Bill", 10, "sfwqerfsdfas");
    Human& c = CreateChinese("zhangsan", 11, "beijing");

    Human* h[2] = {&e, &c};
    int i;
    for (i = 0; i < 2; i++)
        test_eating(h[i]);

    return 0;
}

看到上述代码，第一，头文件中，Englishman.h和Chinese.h不见了，只剩下一个Human.h，正如上面所说，APP的代码只和Human.h有关联；第二，之前有Englishman和Chinese的实例化对象，现在改为了使用函数调用生成Human类的引用，来替代之前的实例化对象。

那自然，这两个函数调用是在Human.h中声明的了，Human.h的代码如下所示:

#ifndef _HUMAN_H
#define _HUMAN_H

#include 
#include 
#include 

using namespace std;

class Human {
private:
    char *name;

public:
    void setName(char *name);
    char *getName(void);
    virtual void eating(void) = 0;
    virtual void wearing(void) = 0;
    virtual void driving(void) = 0;

};

Human& CreateEnglishman(char *name, int age, char *address);
Human& CreateChinese(char *name, int age, char *address);

#endif

为了使得应用编程和类编程相互分离，那么这两个函数的定义自然分别为了Englishman和Chinese了，代码分别如下所示：

/* 当前处于Englishman.cpp中 */
Human& CreateEnglishman(char *name, int age, char *address)
{
    return *(new Englishman(name, age, address));
}

下面是CreateChinese的函数定义，代码如下所示：

Human& CreateChinese(char *name, int age, char *address)
{
    return *(new Chinese(name, age, address));
}

这样一来，就实现了抽象类界面，在更改Englishman和Chinese的代码的时候，不需要重新生成可执行文件，只需要重新生成动态链接库就可以了。

模板

在C++中的模板定义中，模板有两类，一个是函数模板，一个是类模板，在本节的教程中，主要是讲述函数模板的相关内容。

函数模板的引入

为什么要引入函数模板呢，我们来看一下如下所示的代码：

int& max(int& a, int& b)
{
    return (a < b)? b : a;
}

double& max(double& a, double& b)
{
    return (a < b)? b : a;
}

float& max(float& a, float& b)
{
    return (a < b)? b : a;
}

上述的代码是max函数的一个重载，观察这个重载函数，可见，每个重载函数的两个形参是相同的，并且形参和返回值一样，基于此，我们也就可以定义一个函数模板来替代这些函数重载，函数模板定义如下：

template
T& max(T&a,t&B)
{
   return (a < b)? b : a;
}

如何理解上述模板函数呢，实际上也就是说，把类型用T来替换了。

基于模板函数，我们再来实现上述使用重载而实现的功能，代码如下所示：

#include 
#include 
#include 

using namespace std;

template
T& mymax(T& a, T& b)
{
    cout<<__PRETTY_FUNCTION__<    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;
}

上述代码执行的结果如下所示：

image-20210224135710100

可见上述的运行结果显示，虽然是使用的一个函数模板，但是在执行的时候，mymax(ia, ib);、mymax(fa, fb);以及mymax(da, db);实际上是执行了三个不同的函数，这也正是函数模板执行的一个机制，函数模板其特点主要是以下两点：

函数模板只是编译指令，一般写在头文件中；

编译程序的时候，编译器根据函数的参数来“推导”模板的参数；然后生成具体的模板函数

模板函数参数推导过程

模板函数参数的推导过程是一个重要的内容，它主要可以分为如下几个方面：

有限的类型转换

函数模板只支持两种隐式转换

其他隐式转换都不支持

苛刻的类型匹配

参数类型必须完全匹配；如果不能直接匹配，则可以进行”有限的类型转换“，如果还是不匹配，那么就推导失败

• const 转换：函数参数为非 const 引用/指针，它可以隐式地转换为const引用/指针

  数组或者函数指针转换：

数组可以隐式的转换为”指向第一个元素的指针“

参数为”函数的名字“，它隐式地转化为函数指针

基于上述所述的这些特点，接下来通过实例进行阐述，现在基于刚才那个函数模板，我们来编写下面的例子：

using namespace std;

int main(int argc,char **argv)
{
    int a = 1;
    double b = 2.1;
    mymax(a,b);

    return 0;
}

代码编译结果如下所示：

image-20210224142730144

通过上述错误信息，可以看到所给出的信息是没有匹配的函数，只是因为我们传入的参数是int和double，传入这两个参数是函数模板是无法进行推导的，无法进行隐式转换。

针对于上述来讲，函数模板只支持两种隐式转换，那分别是哪两种呢，我们来看具体的例子，我们将函数模板也进行一些更改，更改之后的代码如下所示：

#include 
#include 
#include 

using namespace std;

template
const T& mymax(const T& a, const T& b)
{
    cout<<__PRETTY_FUNCTION__<    return (a < b)? b : a;
}

int main(int argc, char **argv)
{
    int ia = 1;
    int ib = 2;

    mymax(ia, ib);

    return 0;
}

当前这个函数是可以执行通过的，也就是说当函数模板中的形参和返回值带有const的时候，那么对于实参是可以不含const修饰的，也就是说可变的参数可以传入到形参不可变的函数里，但是反过来是不行的，除非两个传进去的变量都是const的。比如如下所示的代码：

#include 
#include 
#include 

using namespace std;

template
T& mymax(T& a, T& b)
{
    cout<<__PRETTY_FUNCTION__<    return (a < b)? b : a;
}

int main(int argc,char** argv)
{
    int ia = 1;
    const int ib = 2;
    mymax(ia,ib);    /* 错误，const 不能隐式转换为非 const */

    const int isa = 1;
    const int isb = 2;
    mymax(isa,isb);  /* 正确 */

    return 0;
}

除了上述的 非const 转 const的例子以外，还有一个是数组和指针的隐式转换，数组可以隐式地转换为“指向第一个元素的指针”，下面是一个关于数组和指针的代码：

#include 
#include 
#include 

using namespace std;

template
const T& mymax(const T& a, const T& b)
{
    cout<<__PRETTY_FUNCTION__<    return (a < b)? b : a;
}

template
const T* mymax2(const T* a, const T* b)
{
    cout<<__PRETTY_FUNCTION__<    return (a < b)? b : a;
}

基于上述编写的两个模板函数，我们依次测试上述所说的指针和数组之间的隐式转换，代码如下所示：

int main(int argc, char** argv)
{
    char a[] = "ab";
    char b[] = "cd";

    mymax(a,b);
    mymax2(a,b);

    return 0;
}

下面是代码执行的结果：

image-20210224145329671

注：cout<<__PRETTY_FUNCTION__< 可以在函数模板内打印匹配结果

根据打印出来的匹配结果，可以看到mymax匹配的T是数组类型，而mymax2匹配的T是char类型，这也证实了上述所说的指针和数组之间的隐式转换。

基于上述的函数模板，我们继续来看一个例子：

int main(int argc, char** argv)
{
    char a2[] = "abc";
    char b2[] = "cd";

    mymax(a2, b2); /* mymax(char[4], char[3]),无法推导出T:mymax(char& [4], char& [3]),因为两个参数不一样*/
    mymax(a2, b2); /* mymax2(char[4], char[3]),可以推导出T:mymax2(const char*,const char*) */

    return 0;
}

通过上述的注释我们可以知道，第6行代码是不能编译通过的，但是第七行代码可以编译通过，因为它使用的模板的参数是指针，而对于数组来说，可以隐式转换为指针，数组名可以隐式转换为指向第一个元素的指针。

上述的几个例子已经说了const和非const的，以及数组和指针的，接下来就是说的是函数指针的，且看下面这个例子：

template
void test_func(T f)
{
    cout<<__PRETTY_FUNCTION__<}

void f1(int a, int b)
{
    return 0;
}

int main(int argc, char **argv)
{
    test_func(f1);
    test_func(&f1);

    return 0;
}

代码执行结果如下所示：

image-20210224151130109

可见对于函数名称来说，上述的两种传入方式都是将 T推导为函数指针的形式。

小结

上述就是本期分享的内容，涉及的代码可以通过百度云链接的方式获取到：

链接：https://pan.baidu.com/s/13_g0L9KBTSVJWDvOrksrfQ
 

提取码：gfsb