【正点原子FPGA连载】 第二章C++基础摘自【正点原子】【正点原子】DFZU2EG_4EV MPSoc之嵌入式Qt开发指南_V1.0

1）实验平台：正点原子MPSoC开发板
2）平台购买地址：https://detail.tmall.com/item.htm?id=692450874670
3）全套实验源码+手册+视频下载地址： http://www.openedv.com/thread-340252-1-1.html

第二章C++基础

在第二章C++基础里，这里主要介绍概念为主，主要介绍C++与C语言中常用的不同点，和一些新的变化。其中不会去说指针、数据类型、变量类型、判断和循环等这些知识，这些和C语言基本是一样使用的。我们主要学习C++的面向对象编程，对学习Qt有很大的帮助，理解第2.2节的概念很重要。Qt里就能体现到C++编程带来的优势和便处。就算没学过C++，学习Qt也不会很难。写C++基础这章，笔者已经把重要的概念写出来，但是实际上C++的内容不止这么多，第二章是快餐式C++入门，主要是为了更好的理解Qt中的C++语法，学习Qt时也方便理解其中的内容。

2.1C++语言新特性

2.1.1.C++的新特性
C++是在C语言基础上开发的一种集面向对象编程、泛型编程和过程化编程于一体的编程语言，是C语言的超集。C++在C语言的基础上新增了很多特性，包括：
类和对象：
继承：
多态、虚函数和RTTI（运行阶段类型识别）：
函数重载：
引用变量：
泛型（独立于类型的）编程，这种技术是由模板和标准模板库(STL)提供的：
处理错误条件的异常机制：
管理函数、类和变量名的名称空间。
关于C++语言的详细介绍，推荐两本书，一本是《C＋＋Primer》，另一本是《C++ Primer Plus》，这两本都是学习C++不错的入门书，任选其中一本即可。要想深入学习C＋＋的读者，推荐看下这两本书，也可以网上搜索C++的经典书籍，请有选择的购买和阅读。
2.1.2.C++的输入输出方式
在C语言里，我们是这样输入或者输出的：

图 2.1.1 C语言的输入和输出
在C++里，我们使用cin和cout代替了scanf和printf。在输入和输出的流程上是不变的，只是关键字变了，用法也变了。

图 2.1.2 C++语言的输入和输出
要说效率上，肯定是C语言的scanf和printf的效率高，但是没有C++中的cin和cout使用方便。
C++的I/O语法方式如下。

cout语法形式：
cout<<x<<endl;

x可以是任意数据类型，甚至可以写成一个表达式，这比C语言需要指定数据类型方便多了，endl指的是换行符，与C语言的“\n”效果一样。
错误示例：
cout<<x,y<<endl; // 在变量间不能用“，”
正确写法：

cout<<x<<y;			// endl可流省略，只是一个换行的效果。
cin语法形式：
cin>>x;
x可以是任意数据类型。
拓展，如何输入两个不同的变量。
cin>>x>>y;

2.1.3.C++之命名空间namespace
在第1.3节里我们已经使用过命名空间，如下代码第2行using namespace std;同时我们要注意第1行，不能写成iostream.h，有.h的是非标准的输入输出流，是c的标准库。无.h的是标准输入输出流就要用命名空间。

#include <iostream>
using namespace std;
int main()
{
    
    
    cout << "Hello, World!" << endl;
    return 0; 
}

using是编译指令，声明当前命名空间的关键词。可以从字面上理解它的意思，using翻译成使用。这样可以理解成使用命名空间std。因为cin和cout都是属于std命名空间下的，所以使用时必须加上using namespace std;这句话。cin和cout也可以写成std::cin和std::cout，“::”表示作用域，cin和cout是属于std命名空间下的，这里可以理解成std中的cin和std中的cout。
为什么要使用命名空间？
有些名字容易冲突，所以会使用命名空间的方式进行区分，具体来说就是加个前缀。比如 C++ 标准库里面定义了vector容器，您自己也写了个 vector 类，这样名字就冲突了。于是标准库里的名字都加上std::的前缀，您必须用 std::vector 来引用。同理，您自己的类也可以加个自定义的前缀。但是经常写全名会很繁琐，所以在没有冲突的情况下您可以偷懒，写一句using namespace std;，接下去的代码就可以不用写前缀直接写 vector 了。
从命名空间开始我们就隐隐约约可以看到C++面向对象的影子了。命名空间在很多C++库里使用到。有些公司也会自定义自己的C++库，里面使用了大量的命名空间。从这里我们也可以看出C++是非常有条理的，容易管理的，不含糊，易使用的。
在初学Qt时我们是比较少使用命名空间，或者比较少看到命名空间。当然也是可以在Qt里自定义命名空间，然后与C++一样正常使用。
下面通过一个简单的例子来介绍自定义的命名空间和使用自定义的命名空间。在Ubuntu上我们新建一个02_namespace_example目录，然后在02_namespace_example里新建一个02_namespace_example.cpp文件，其内容如下：

#include <iostream>
using namespace std;

namespace A
{
    
    
    int x = 1;
    void fun() {
    
    
        cout<<"A namespace"<<endl;
    }
}
using namespace A;
int main()
{
    
    
    fun();
    A::x = 3;
    cout<<A::x<<endl;
    A::fun();
    return 0;
}

第4行，自定义了命名空间A，里面定义了一个变量x，并将x赋值为1；定义了一个函数fun()，fun()的函数体为输出打印语句cout<<“A namespace”<<endl;。
第11行，声明使用命名空间A。
第14行，在第11行声明了命名空间A后，才能直接使用fun();否则要写成A::fun();
第15行，将A命名空间下的x重新赋值为3。
第16行，打印出A命名空间下的x的值。
第17行，调用A命名空间下的fun()。
执行下面的指令开始编译。
g++ 02_namespace_example.cpp -o 02_namespace_example
编译完成执行的结果如下

图 2.1.3执行结果
2.2C++面向对象
面向对象的三大特征是继承，多态和封装，C++面向对象重要的就是这些，下面我们通过一些简单的实例加以理解，从这小节开始，我们将开启新的编程旅途。与C语言编程的思想完全不同了，这就是C++!理解概念和掌握这些编程方法对学习C++有很大的好处。

2.2.1.类和对象

C++ 在 C 语言的基础上增加了面向对象编程，C++支持面向对象程序设计。类是C++的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。
打个比方说明一下什么是类，比如有一条小狗，小狗有名字叫旺财，旺财的年龄是2岁，同时旺财会汪汪的叫，也能跑。我们统称狗这个为一类，类是我们抽象出来的，因为狗不只有上面的属性，还有体重，毛发的颜色等等，我们只抽象出几种属性成一个类。具体到哪条狗就叫对象。
从类中实例化对象分两种方法，一种是从栈中实例化对象，一种是从堆中实例化对象。
下面以自定义Dog类介绍如何自定义类和如何使用对象。
在Ubuntu上新建一个03_class_dog_example目录，在03_class_dog_example 目录下添加一个03_class_dog_example.cpp文件，文件内容如下：

1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   class Dog
6   {
    
    
7   public:
8       string name;
9       int age;
10
11      void run() {
    
    
12          cout<<"小狗的名字是:"<<name<<","<<"年龄是"<<age<<endl;
13      }
14  };
15
16  int main()
17  {
    
    
18      Dog dog1;
19
20      dog1.name = "旺财";
21      dog1.age = 2;
22      dog1.run();
23
24      Dog *dog2 = new Dog();
25
26      if (NULL == dog2) {
    
    
27          return 0;
28      }
29      dog2->name = "富贵";
30      dog2->age = 1;
31      dog2->run();
32
33
34      delete dog2;
35      dog2 = NULL;
36      return 0;
37  }

注：每行前面的数字为行号，添加到文件中时要去掉。
第5行，定义了一个Dog类。定义类时，起的类名要尽量贴近这个类，让人一看就明白，您这个类是做什么的。
第7行，访问限定符public（公有的），此外还有private（私有的）和protected（受保护的）。写这个的目的是为了下面我们要调用这些成员，不写访问限定符默认是private。关于访问限定符，如果是初学者可能会难理解。简单的来说，访问限定符就是设置一个成员变量和成员函数的访问权限而已，初学者暂时不必要深究什么时候应该用public和什么时候应该用private。
第8至11行，定义了一个字符串变量name，整形变量age。和一个方法run()。我们在这个run()里打印相应的Dog名和Dog的年龄。PS：string是C++的数据类型，方便好用，使用频率相当高。
第18行，从栈中实例化一个对象dog1(可以随意起名字)。
第20至22行，为dog1的成员变量赋值，dog1的name赋值叫“旺财”，年龄为2岁。然后调用run()方法，打印dog1的相关变量的信息。
第24行，从堆中实例化对象，使用关键字new的都是从堆中实例化对象。
第26行，从堆中实例化对象需要开辟内存，指针会指向那个内存，如果new没有申请内存成功，即指向NULL，程序就自动退出，下面的就不执行了，写这个是为了严谨。
第29至31行，和dog1一样，为dog2的成员赋值。
第34和35行，释放内存，将dog2重新指向NULL。
如果没有语法错误，我们完全可以预测到打印的结果。我们学习C语言的结构体，类其实和结构类似，可以说类是结构体的升级版本。
执行下面的指令开始编译。
g++ 03_class_dog_example.cpp -o 03_class_dog_example
编译完成后执行的结果如下：

图 2.2.1执行结果
通过上面的例子我们已经学习了什么是类，和什么是对象。以描述Dog为一类（抽象出来的），从Dog类中实例出来就是对象（实际事物）。对象拥有Dog类里的属性，可以从栈中实例化对象，亦可从堆中实例化对象。类的编写过程和对象的使用过程大致如上了。我们只需要理解这个步骤，明白类的定义和使用即可。

2.2.2.构造函数与析构函数

什么是构造函数？构造函数在对象实例化时被系统自动调用，仅且调用一次。构造函数出现在哪里？前面我们学过类，实际上定义类时，如果没有定义构造函数和析构函数，编译器在某些情况下就会生成一个构造函数和析构函数，只是这个构造和析构函数什么事情也不做，所以我们不会注意到一点。
构造函数的特点如下：
（1） 构造函数必须与类名同名；
（2） 可以重载，（后面会讲解什么是重载）；
（3） 没有返回类型，即使是void也不行。
什么是析构函数？与构造函数相反，在对象结束其生命周期时系统自动执行析构函数。实际上定义类时，编译器会生成一个析构函数。
析构函数的特点如下：
（1） 析构函数的格式为~类名()；
（2） 调用时释放内存（资源）；
（3） ~类名()不能加参数；
（4） 没有返回值，即使是void也不行。
下面我们通过简单的例子来说明构造函数和析构函数的使用。新建一个04_structor_example目录，添加一个04_structor_example.cpp文件，文件内容如下：

1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   class Dog
6   {
    
    
7   public:
8       Dog();
9       ~Dog();
10  };
11
12  int main()
13  {
    
    
14      Dog dog;
15      cout<<"构造与析构函数示例"<<endl;
16      return 0;
17  }
18
19  Dog::Dog()
20  {
    
    
21      cout<<"构造函数执行！"<<endl;
22  }
23
24  Dog::~Dog()
25  {
    
    
26      cout<<"析构函数执行！"<<endl;
27  }

我们还是以简单的Dog类作为示例，定义一个Dog类，把构造函数和析构函数写上。前面不是说会自动生成构造函数和析构函数的吗？注意是编译时，编译器生成的。当我们要使用构造函数和析构函数时需要我们自己在类里添加。
第5至第10行，定义了一个Dog类，并在里面写了构造函数和析构函数。
第14行，使用Dog类实例化一个dog对象。
第15行，打印一句"构造与析构函数示例"。
第19至22行，类的函数可以在类里实现，也可以在类外实现，不过在类外实现时需要使用“::”，此时我们把类的构造函数定义在类的外面，打印一句"构造函数执行！“。
第24至27行，类的析构函数定义在类的外面，打印一句"析构函数执行！”。
执行下面的指令开始编译。
g++ 04_structor_example.cpp -o 04_structor_example
编译完成后执行的结果如下。

图 2.2.2 执行结果
其实执行的结果也是可以预测的，在对象实例化时会调用构造函数，所以Dog()先执行，然后再在main()函数里继续执行cout<<“构造与析构函数示例”<<endl;。最后对象生命周期结束时才会执行析构函数。

2.2.3.this指针

一个类中的不同对象在调用自己的成员函数时，其实它们调用的是同一段函数代码，那么成员函数如何知道要访问哪个对象的数据成员呢？
没错，就是通过this指针。每个对象都拥有一个this指针，this指针记录对象的内存地址。
在C++中，this指针是指向类自身数据的指针，简单的来说就是指向当前类的当前实例对象。
关于类的this指针有以下特点：
（1） this只能在成员函数中使用，全局函数、静态函数都不能使用this。实际上，成员函数默认第一个参数为T * const this。也就是一个类里面的成员函数int func(int p)，func的原型在编译器看来应该是int func(T * const this,int p)。
（2） this在成员函数的开始前构造，在成员函数的结束后清除。
（3） this指针会因编译器不同而有不同的放置位置。可能是栈，也可能是寄存器，甚至全局变量。
下面以简单的例子来说明this的用法。我们还是以狗类为例，按上面的this解释，this只能够在成员函数使用，并可以指向自身数据。我们就可以写这样简单的例子来说明this的用法。我们在Qt里也会遇到this，下面这个例子就很容易解释Qt里的this指针的用法。
新建一个05_this_pointer_example目录，添加并编辑

05_this_pointer_example.cpp文件，内容如下：
1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   class Dog
6   {
    
    
7   public:
8       string name;
9       void func();
10  };
11
12  int main()
13  {
    
    
14      Dog dog;
15      dog.func();
16      return 0;
17  }
18
19  void Dog::func()
20  {
    
    
21      this->name = "旺财";
22      cout<<"小狗的名字叫："<<this->name<<endl;
23  }

第21和22行，在类的成员函数里使用了this指针，并指向了类里的成员name。先将name赋值叫“旺财”，然后我们打印name的值。
当程序没有语法错误时我们可以预测打印的结果，就是“小狗的名字叫：旺财”。
执行下面的指令开始编译。
g++ 05_this_pointer_example.cpp -o 05_this_pointer_example
程序执行的结果如下：

图 2.2.3 执行结果
2.2.4.继承
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。
当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。在Qt里大量的使用了这种特性，当Qt里的类不满足自己的要求时，我们可以重写这个类，就是通过继承需要重写的类，来实现自己的类的功能。
一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：
class derived-class: access-specifier base-class
与类的访问修饰限定符一样，继承的方式也有几种。其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。
下面来捋一捋继承的方式，例子都是以公有成员和公有继承来说明，其他访问修饰符和其他继承方式，大家可以在教程外自己捋一捋。这个公有成员和继承方式也没有什么特别的，无非就是不同的访问权限而已，可以这样简单的理解。

1. 公有继承（public）：当一个类派生继承公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
2. 保护继承（protected）： 当一个类派生继承保护基类时，基类的公有和保护成员将成为派生类的保护成员。
3. 私有继承（private）：当一个类派生继承私有基类时，基类的公有和保护成员将成为派生类的私有成员。
   下面我们还是以Dog类为例，在2.2.1小节里我们定义的Dog类，已经定义了name，age和run()方法。假设我们不想重写这个Dog类，而是新建一个Animal类，让Dog类去继承这个Animal类。假设是公有继承，那么我们是不是可以在Dog类实例的对象里使用继承Animal类里的成员呢？带着这个疑问，我们使用下面的例子来说明。
   新建一个目录06_inherit_example，编辑一个06_inherit_example.cpp内容如下

1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   /*动物类，抽象出下面两种属性，
6    *颜色和体重，是每种动物都具有的属性 
7    */
8   class Animal
9   {
    
    
10  public:
11      /* 颜色成员变量 */
12      string color;
13      /* 体重成员变量 */
14      int weight;
15  };
16
17  /*让狗类继承这个动物类，并在狗类里写自己的属性。
18   *狗类拥有自己的属性name，age，run()方法，同时也继承了
19   *动物类的color和weight的属性 
20   */
21  class Dog : public Animal
22  {
    
    
23  public:
24      string name;
25      int age;
26      void run();
27  };
28
29  int main()
30  {
    
    
31      Dog dog;
32      dog.name = "旺财";
33      dog.age = 2;
34      dog.color = "黑色";
35      dog.weight = 120;
36      cout<<"狗的名字叫："<<dog.name<<endl;
37      cout<<"狗的年龄是："<<dog.age<<endl;
38      cout<<"狗的毛发颜色是："<<dog.color<<endl;
39      cout<<"狗的体重是："<<dog.weight<<endl;
40      return 0;
41  }

第21行，Animal作为基类，Dog作为派生类。Dog继承了Animal类。访问修饰符为public（公有继承）。
执行下面的指令开始编译。
g++ 06_inherit_example.cpp -o 06_inherit_example
编译完成执行的结果为如下：

图 2.2.4 执行结果

2.2.5.重载

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。
当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。
函数重载
在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。我们不能仅通过返回类型的不同来重载函数。在Qt源码里，运用了大量的函数重载，所以我们是有必要学习一下什么是函数重载。不仅在C++，在其他语言的里，都能看见函数重载。因为需要不同，所以有重载各种各样的函数。
下面通过一个小实例来简单说明一下函数重载的用法。我们还是以狗类为说明，现在假设有个需求。我们需要打印狗的体重，分别以整数记录旺财的体重和小数记录旺财的体重，同时以整数打印和小数打印旺财的体重。那么我们可以通过函数重载的方法实现这个简单的功能。
新建一个目录07_func_overloading，编辑一个07_func_overloading.cpp内容如下

1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   class Dog
6   {
    
    
7   public:
8       string name;
9       void getWeight(int weight) {
    
    
10          cout<<name<<"的体重是："<<weight<<"kG"<<endl;
11      }
12      
13      void getWeight(double weight) {
    
    
14          cout<<name<<"的体重是："<<weight<<"kG"<<endl;
15      }
16  };
17
18  int main()
19  {
    
    
20      Dog dog;
21      dog.name = "旺财";
22      dog.getWeight(10);
23      dog.getWeight(10.5);
24      return 0;
25  }

第9行，写了一个方法getWeight(int weight)，以int类型作为参数。
第13行，以相同的函数名getWeight，不同的参数类型double weight，这样就构成了函数重载。
第22行与第23行，分别传进参数不同的参数，程序就会匹配不同的重载函数。
执行下面的指令编译。
g++ 07_func_overloading.cpp -o 07_func_overloading
程序执后的结果如下

图 2.2.5 执后结果
通过上面的例子我们可以知道重载函数的使用方法，避免用户传入的参数类型，有可能用户传入的参数类型不在我们写的重载函数里，假若用户传入了一个字符串类型，这样编译器就会匹配不到相应的重载函数，编译时就会报错。其实我们还可以多写几个重载函数，设置多几种类型，如string类型，char类型，float类型等。
运算符重载
运算符重载的实质就是函数重载或函数多态。运算符重载是一种形式的C++多态。目的在于让人能够用同名的函数来完成不同的基本操作。要重载运算符，需要使用被称为运算符函数的特殊函数形式，运算符函数形式：operatorp（argument-list），operator 后面的’p’为要重载的运算符符号。重载运算符的格式如下：
<返回类型说明符> operator <运算符符号>(<参数表>)
{

 <函数体>

}
下面是可重载的运算符列表：
双目算术运算符 + (加)，-(减)，(乘)，/(除)，% (取模)
关系运算符 ==(等于)，!= (不等于)，< (小于)，> (大于)，<=(小于等于)，>=(大于等于)
逻辑运算符 ||(逻辑或)，&&(逻辑与)，!(逻辑非)
单目运算符 + (正)，-(负)，(指针)，&(取地址)
自增自减运算符 ++(自增)，–(自减)
位运算符 | (按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移)
赋值运算符 =, +=, -=, =, /= , % = , &=, |=, ^=, <<=, >>=
空间申请与释放 new, delete, new[ ] , delete[]
其他运算符 ()(函数调用)，->(成员访问)，,(逗号)，
下面是不可重载的运算符列表：
成员访问运算符 .
成员指针访问运算符 ., ->*
域运算符 ::
长度运算符 sizeof
条件运算符 ?:
预处理符号 #
根据上表我们知道可以重载的运算符有很多，我们以重载“+”运算符为例，实际上用重载运算符我们在实际应用上用的比较少，我们只需要了解和学习这种思想即可。
下面的实例使用成员函数演示了运算符重载的概念。在这里，对象作为参数进行传递，对象的属性使用this运算符进行访问。下面还是以我们熟悉的狗类为例。声明加法运算符用于把两个 Dog 对象相加的体重相加，返回最终的 Dog 对象然后得到第三个Dog对象的体重。
新建一个目录08_operator_example，编辑一个08_operator_example.cpp内容如下：

1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   class Dog
6   {
    
    
7   public:
8       int weight;
9       Dog operator+(const Dog &d) {
    
    
10          Dog dog;
11          dog.weight = this->weight + d.weight;
12          return dog;
13      }
14      
15  };
16
17  int main()
18  {
    
    
19      Dog dog1;
20      Dog dog2;
21      Dog dog3;
22      
23      dog1.weight = 10;
24      dog2.weight = 20;
25      dog3 = dog1 + dog2;
26      cout<<"第三只狗的体重是："<<dog3.weight<<endl;
27      return 0;
28  }

第9至13行，重载“+”运算符，注意函数必须与类名同名，把Dog对象作为传递，使用 this运算符进行访问。然后返回一个dog对象。
执行下面指令进行编译。
g++ 08_operator_example.cpp -o 08_operator_example
编译完成后运行的结果如下

图 2.2.6执行结果
结果可以预知的，重载运算符“+”，可以把两个对象进行相加。在普通的算术运算符“+”是不能将两个对象进行相加的，所以我们重载运算符的意义可以体现在这里。

2.2.6.多态

C++多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数；
形成多态必须具备三个条件：

1. 必须存在继承关系；
2. 继承关系必须有同名虚函数（其中虚函数是在基类中使用关键字virtual声明的函数，在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数）；
3. 存在基类类型的指针或者引用，通过该指针或引用调用虚函数。
   这里我们还需要理解两个概念：
   虚函数：
   是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。虚函数声明如下：virtual ReturnType FunctionName(Parameter) 虚函数必须实现，如果不实现，编译器将报错
   纯虚函数：
   若在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。纯虚函数声明如下： virtual void funtion1()=0; 纯虚函数一定没有定义，纯虚函数用来规范派生类的行为，即接口。包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用。
   上面那些概念大家可以捋一捋，毕竟C++概念还是挺多的。为什么说到多态要与虚函数和纯虚函数扯上关系？光说概念没有实例确实难理解。下面我们还是以我们熟悉的狗类和动物类，另外加一个猫类进行多态的讲解。
   新建一个目录09_polymorphism_example，编辑一个09_polymorphism_example.cpp内容如下。（PS: polymorphism翻译多态的意思，笔者就以这种方式命名例程了）

1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   /* 定义一个动物类 */
6   class Animal
7   {
    
    
8   public:
9       virtual void run() {
    
    
10          cout<<"Animal的run()方法"<<endl;
11      }
12  };
13
14  /* 定义一个狗类，并继承动物类 */
15  class Dog : public Animal
16  {
    
    
17  public:
18      void run() {
    
    
19          cout<<"Dog的run()方法"<<endl;
20      }
21      
22  };
23
24  /* 定义一个猫类，并继承动物类 */
25  class Cat : public Animal
26  {
    
    
27  public:
28      void run() {
    
    
29          cout<<"Cat的run()方法"<<endl;
30      }
31      
32  };
33
34  int main()
35  {
    
    
36      /* 声明一个Animal的指针对象，注：并没有实例化 */
37      Animal *animal;
38      /* 实例化dog对象 */
39      Dog dog;
40      /* 实例化cat对象 */
41      Cat cat;
42      
43      /* 存储dog对象的地址 */
44      animal = &dog;
45      /* 调用run()方法 */
46      animal->run();
47      
48      /* 存储cat对象的地址 */
49      animal = &cat;
50      /* 调用run()方法 */
51      animal->run();
52      return 0;
53  }

第9行、第18行和第28行，都有一个run()方法。其中我们可以看到基类Animal类的run()方法前面加了关键字virtual。这样让基类Animal类的run()方法变成了虚函数。在这个例子里我们可以知道虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。简单的来说，上面的实例是基类Animal声明了一个指针animal。然后通过基类的指针来访问Dog类对象与Cat类的对象的run()方法，前提是基类的run()方法必须声明为虚函数，如果不声明为虚函数，基类的指针将访问到基类自己的run()方法。我们可以尝试把virtual关键字去掉再重新编译测试，如果不加关键字virtual会是什么情况。
第44行和第49行，可以理解是animal指针实例化的过程。当基类的run()方法定义成虚函数，编译器不静态链接到该函数，它将链接到派生类的run()方法，进行实例化。
执行下面的指令编译。
g++ 09_polymorphism_example.cpp -o 09_polymorphism_example
编译完成执行的结果如下

图 2.2.7执行结果
2.2.7.数据封装
封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。
数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制，C++ 通过创建类来支持封装和数据隐藏（public、protected、private）。
其实我们在第2.2小节开始就已经接触了数据封装。在C++程序中，任何带有公有和私有成员的类都可以作为数据封装和数据抽象的实例。通常情况下，我们都会设置类成员状态为私有（private），除非我们真的需要将其暴露，这样才能保证良好的封装性。这通常应用于数据成员，但它同样适用于所有成员，包括虚函数。
下面我们还是以狗类为例，增加一个食物的方法addFood(int number)。将获得食物的方法设定在public下，这样addFood(int number)方法就暴露出来了，也就是对外的接口。然后我们设置狗类的私有成员(private)食物的份数total。我们在这个教程里第一次使用private，在这章节里我们也可以学到什么时候该使用private什么时候使用public。total为获得的食物总数，然后我们还写一个公开的方法getFood()在public下，通过getFood()来打印出小狗总共获得了几份食物。
新建一个目录10_encapsulation_example，编辑一个10_encapsulation_example.cpp内容如下。（PS: encapsulation翻译封装的意思）。

1   #include <iostream>
2   #include <string>
3   using namespace std;
4 
5   class Dog
6   {
    
    
7   public:
8       string name;
9       
10      Dog(int i = 0)
11      {
    
    
12          total = i;
13      }
14      
15      void addFood(int number) {
    
    
16          total = total + number;
17      }
18      
19      int getFood() {
    
    
20          return total;
21      }
22  private:
23      int total;
24  };
25
26
27  int main()
28  {
    
    
29      Dog dog;
30      
31      dog.name = "旺财";
32      
33      dog.addFood(3);
34      dog.addFood(2);
35      
36      cout<<dog.name<<"总共获得了"<<dog.getFood()<<"份食物"<<endl;
37      
38      return 0;
39  }

第10至第13行，在构造函数里初始化total的数量，不初始化total的数量默认是随int类型的数。所以我们需要在构造函数里初始化，也体现了构造函数的功能，一般是在构造函数里初始化。不要在类内直接赋值初始化，有可能有些编译器不支持。
第15至17行，addFood(int number)，在这个方法里，将获得的食物份数赋值给total。
第19至21，getFood()，在这个方法里，将返回食物的总份数。通过调用这个方法，即可访问私有成员的total总数。
第33和34行，添加食物的份数。
第36行，打印食物的总份数。
执行下面的指令编译。
g++ 10_encapsulation_example.cpp -o 10_encapsulation_example
编译完成执行的结果如下：

图 2.2.8执行结果
2.2.8.数据抽象
数据抽象是指，只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。数据抽象是一种依赖于接口和实现分离的编程（设计）技术。
数据抽象的好处：

1. 类的内部受到保护，不会因无意的用户级错误导致对象状态受损。
2. 类实现可能随着时间的推移而发生变化，以便应对不断变化的需求，或者应对那些要求不改变用户级代码的错误报告。
   举个简单的例子，比如我们生活中的手机。手机可以拍照、听音乐、收音等等。这些都是手机上的功能，用户可以直接使用。但是拍照的功能是如何实现的，是怎么通过摄像头取像然后怎么在屏幕上显示的过程，作为用户是不需要知道的。也就是暴露的不用太彻底，用户也不必须知道这种功能是如何实现的，只需要知道如何拍照即可。
   就 C++ 编程而言，C++ 类为数据抽象提供了可能。它们向外界提供了大量用于操作对象数据的公共方法，也就是说，外界实际上并不清楚类的内部实现。
   其实像cout这个对象就是一个公共的接口，我们不必要知道cout是如何在屏幕上显示内容的。cout已经在底层实现好了。
   在上一节我们已经学习过数据封装，数据封装是一种把数据和操作数据的函数捆绑在一起的机制，而数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。
   C++ 程序中，任何带有公有和私有成员的类都可以作为数据抽象的实例。例子略，例子可参考上一小节的例子。
   2.2.9.接口（抽象类）
   接口描述了类的行为和功能，而不需要完成类的特定实现。C++ 接口是使用抽象类来实现的，抽象类与数据抽象互不混淆，数据抽象是一个把实现细节与相关的数据分离开的概念。如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 “= 0” 来指定的。
   设计抽象类（通常称为 ABC）的目的，是为了给其他类提供一个可以继承的适当的基类。抽象类不能被用于实例化对象，它只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。
   因此，如果一个 ABC 的子类需要被实例化，则必须实现每个虚函数，这也意味着 C++ 支持使用 ABC 声明接口。如果没有在派生类中重写纯虚函数，就尝试实例化该类的对象，会导致编译错误。可用于实例化对象的类被称为具体类。
   根据概念我们来写个实例来说明抽象类。
   还是以Dog类为说明，例程与2.2.6小节类似，只是Aninmal类的run()方法定义为纯虚函数，纯虚函数不用实现，由派生类Dog和Cat类实现重写即可。
   新建一个目录11_abstract_class，编辑一个11_abstract_class.cpp内容如下

1   #include <iostream>
2 
3   using namespace std;
4 
5   /* 定义一个动物类 */
6   class Animal
7   {
    
    
8   public:
9       virtual void run() = 0;
10  };
11
12  /* 定义一个狗类，并继承动物类 */
13  class Dog : public Animal
14  {
    
    
15  public:
16      void run() {
    
    
17          cout<<"Dog的run()方法"<<endl;
18      }
19
20  };
21
22  /* 定义一个猫类，并继承动物类 */
23  class Cat : public Animal
24  {
    
    
25  public:
26      void run() {
    
    
27          cout<<"Cat的run()方法"<<endl;
28      }
29
30  };
31
32  int main()
33  {
    
    
34      /* 实例化dog对象 */
35      Dog dog;
36      
37      /* 实例化cat对象 */
38      Cat cat;
39
40      /*  dog调用run()方法 */
41      dog.run();
42      
43      /* cat调用run()方法 */
44      cat.run();
45      
46      return 0;
47  }

执行下面指令进行程序编译。
g++ 11_abstract_class.cpp -o 11_abstract_class
程序运行的结果如下：

图 2.2.9执行结果
虽然结果和例程与2.2.6一样，但是却表现了两种不同的思想。学C++重要的是思想，当我们对这种思想有一种的了解后，不管是Qt或者其他C++程序，我们都能快速学习和了解。C++的内容就到此结束了。在这个C++基础中，我们的例子非常简单，也十分之易懂，重要的是理解概念，许多C++的课程都是以C++的功能甚至是很复杂的算法作讲解，内容复杂且多。只要我们理解好上面的C++的基础，对学习C++有很大的帮助，不要求对C++有很深的理解，至少在我们后面学习Qt时已经大概了解Qt中的C++语法。