c++的类的封装／继承／多态的简单介绍

　本篇文章仅仅从很表层来介绍一个C++语言中的类，包括什么是类，类的封装性／继承性和多态性。高手直接跳过吧，看了浪费时间，新手或者想温习一下的可以浏览看看。

1. 什么是类？

到底什么是类(class)？？类就是一种类型，是用户自己定义的一个类型，和内置类型如int/float/double类似，  用一个类可以去定义一个变量，即课本中所谓的类的实例化，会得到一个object。类这个类型比较特别，它即包括了数据（数据成员），又包含了若干个操作这些数据的方法（即成员函数）。为什么需要类呢？类提供了一种对事物的抽象，增强了事物的聚合性，类让我们可以把一个事物当作一个整体去看，方便描述，方便建模。 例如：我们可以定义一个学生的类：包括了姓名／性别／年龄／学号ID等信息

   class Student
   {
   public:
           int GetID();
           string GetName();
           string GetSex();
           int GetAge();

           void SetID(int ID_);
          void SetName(string Name_);
          void SetSex(string Sex_);
          void SetAge(int Age_); 

  private:
          string m_Name;
          string m_Sex;
          int m_ID;
          int m_Age
  };           

如上所示，我们定义了一个Student的类， 定义它之后，编译器就不光知道了Student是一个类型，而且知道了类型的一些细节，例如当使用该类型去定义一个变量(object)时，需要分配多少内存等，例如：

     // 输入Student类型在内存中占多少字节
     cout << "Student类型的大小为:" << sizeof(Student) << endl;

     //实例化一个叫小明的学生，并命名为SB（有点矛盾）
     Student xiaoming;
     xiaoming.SetName("SB");
     cout << xiaoming.GetName() << endl;

接下来，详细说说如何定义一个类：

定义一个类，需要做的是：1. 声明类拥有的数据成员， 2. 声明类拥有的成员函数：

 class Dog
 {
 public:
     int Age;
     int GetAge();
 };

成员函数在哪里定义呢？即可以在类的内部直接定义，也可以在类的外部进行定义（此时，需要指明所属的类）。当定义在类的内部时，默认声明为inline函数。 当类外部定义成员函数时，可以有类内声明为inline函数，也可以在定义时候声明了inline函数，但是个人更喜欢在类外定义的时候声明为inline函数，这样可以根据自己定义一个函数的实际情况，决定是否声明为inline函数，而不需要提前考虑好。

 // 类的内部定义
 class Dog
 {
 public:
     int Age;
     int GetAge()    //当定义在类的内部时，默认声明为inline函数
     {
         return Age;
     }
 };

 // 类外部定义
 class Dog
 {
 public:
     int Age;
     int GetAge();
 };

 Dog::GetAge()
 {
     return Age;
 }

 // 类外部定义,显示声明为inline函数
 class Dog
 {
 public:
     int Age;
     inline int GetAge();
 };

另外：

1. 类成员函数通过隐式this指针访问类内部的数据成员的; 如果把this指针修饰为const，在成员函数后面加const ,这就是const 成员函数:  GetAge() const 
2.  编译器在解析一个类，总是先把类内部的数据成员解析完毕，再去处理成员函数，因此，定义一个类时，不必关心数据成员与成员函数的先后位置，数据成员圣成员函数问题可见的。
3. 一个类域也是一个作用域（用{ }括起来的部分），正因为如此， 1. 在类的外部定义成员函数时，指定类名就进入了类的作用域中了，就可以找到数据成员了; 2. 对类内的静态数据成员与静态成员函数，可以通过类名作用域访问（对非静态的不可以，因为非静态的数据成员属于具体的一个对象而不属于类，虽然非静态的成员函数实际上在多个对象之间是共享的，但是也只能通过对象名对象的指针访问，因为它们有隐式的this指针）

2. 类的封装性

封装性就是说可以把一部分东西封装起来，不让别人看到。在C＋＋中，类这种类型通过它的访问控制符来体现了它的封装性，包括：

public: 公有的，在类的外部放着，谁都可以看到；
protected: 保护性的，只让它的子类可以看到；
private: 私有的，即把它们封装在了类的内部，在类的外面是看不到的，只有类内部的人可以看到；

例如：定义了一个House的类，House外面的只能看到pulic下的内容，而在House里面，可以看到所有内容;

 class House
 {
 public:
     int Windows;
     void OpenWindow();
     int doors;
     void OpenDoors();

 protected:
     int *** // 这个不好举例子

 private:
     int Desk;
     int light;
     void OpenLight();
 }

使类具有封装性的目的是：我们可以定义一些类，只对类的使用者留一下公有的接口（即pulic下的内容），而类内部的相关操作对类的使用者来说是透明的，用户不操心。我可以随便改类内部的代码，只有公有的接口不变，类的用户的代码是不需要调整的。保证数据安全，方便用户使用，大家都省心啊。

3. 类的继承

如果我们想在一个类的基础上继续创建一个新类，这就用到了类的继承性。继承可以使用三个访问标志符控制：public、protectd和private。  无论哪个继承，对直接子类没有任何影响，只对子类的用户有影响。基类中的private成员无论使用哪个访问标志符，子类的用户是看不到的，基类的public与protected成员是否能让子类的用户看到由三种访问标志符控制 。

public继承： 基类内的数据成员与成员函数封装特性不变在子类中不变
protected继承： 基类内的数据成员与成员函数的public部分在子类中变为protected
private继承： 基类内的数据成员与成员函数的public和protected部分变为private

例如：

 class Base
 {
 public:
     *****
 protected:
     *****
 };

 // 公有继承
 class Derived1 : public Base
 {
 public:
     .....
 private:
     ....
 };

 // 私有继承
 class Derived2 : private Base
 {
 public:
     ;;;;;;
 };

a. 基类中虚函数和纯虚函数

思考这么一个问题： 当基类定义了某个函数，而在子类中又定义了一个同名的函数（返回类型与参数列表可以不同），这时会发生什么？
答： 子类内的该函数会隐藏基类中同名的函数。即使他们的参数列表与返回类型不同，也不会发生重载，因为重载必须在相同的作用域内发生，如果作用域不同，编译器查找时，总会先找到最近作用域内的同名函数。

很多时候，我们想在基类与子类中定义相同的接口（即同名函数），它们实现各自的功能，这就可以把这样的函数声明为虚函数，即virtual.   当通过类的指针与引用调用虚函数时，会发生动态绑定，即多态。如下面例子所示：

 // 程序
 #include<iostream>
 using namespace std;

 class Base
 {
 public:
     virtual void Say() {cout << "I am Base!" << endl;}
 };

 class Derived : public Base
 {
 public:
     virtual void Say() {cout << "I am Derived!" << endl;}
 };

 int main()
 {
     Base* pA = new Base;
     Derived* pB = new Derived;
     pA->Say();
     pB->Say();
 }

 // 输出
 yin@debian-yinheyi:~/c$ ./a.out
 I am Base!
 I am Derived!

当我们不想实例化一个类时，我们可以定义一个抽象基类，它只负责提供接口。包含纯虚函数的类为抽象类。纯虚函数必须在子类中进行声明与定义。而虚函数可以不在子类中声明与定义，这时候它会像普通成员函数一样继承基类中的虚函数的实现。

 class Base
 {
 public:
     virtual void Say() = ;     //纯虚函数
 }; 

总结来说：

1. 当我们要继承一个类的接口与实现时，我们在基类中定义普普通通的成员即可。
2. 当我们想要继承一个类的接口与默认的实现时，我们在基类中定义为虚函数。
3. 当我们只要继承一个类的接口时，我们在基类中定义为纯虚函数。

其它说明：

1. 在子类中，当我们重新声明和定义虚函数时，可以加上virtual关键字(virtual只能用在类内，不可以把virtual 用在类外），也可以不加， 在c++11标准中，引入了override关键字来显示表示覆盖基类中虚函数的定义，override关键字有利于给编译器更多信息，用于查错。例如当我们在子类中定义了一个与基类中虚函数名字相同，但是参数列表不同的函数，我们本意是定义子类特有的虚函数版本，来覆盖基类中的版本。然而这时候，基类与子类中的函数是独立的，只是基类中的版本隐藏了而已。如果使用了override，编译器发现没有覆盖，就会报错。 如果我们不想让基类中的某个虚函数被覆盖掉，可以使用final关键字。（另外覆盖，即override只会发生在虚函数身上）

2. 如果我们定义 了一个类，并且不想该类被继承，可以在定义这个类时，在类名后面加上final关键字。

 class Base
 {
 public:
     virtual void Say() {cout << "I am Base!" << endl;}
     virtual void Dad() final { cout << " I am your dad!" << endl;}   //对该虚函数使用final关键字
 };

 class Derived final : public Base       // 对类Derived 使用了final 关键字
 {
 public:
     void Say() override { cout << " I am Derived!" << endl;}        //使用了override关键字
 };

3. 虽然一个纯虚函数不需要定义，但是其实我们是可以定义一个纯虚函数的，不过调用它的唯一途径是”调用时明确指出它的class的名称“。

 // 程序
 class Base
 {
 public:
     virtual void Hello() = ;
 };
 void Base::Hello() {cout << "hello " << endl;}                                                                                                                                                  

 class Derived final : public Base
 {
 public:
     void Hello() override {cout << "a,很疼的" << endl;}
 };

 int main()
 {
     Derived* pB = new Derived;
     pB->Hello();
     pB->Base::Hello();
 }

 // 输出
 yin@debian-yinheyi:~/c$ ./a.out
 a,很疼的
 hello 

4. 基类与子类中的虚函数的返回类型和参数列表必须完全一致，如果不一致的话，编译器认为他们是完全不相关的函数。他们之间不会发生覆盖(override)，子类中的同名函数只会隐藏子类中的同名函数。

b. 继承中的作用域

关于类的作用域，我们要明白以下几点：

1. 类本身是一个作用域，使用{ }括起来的。
2. 在类的继承过程中，子类的作用域是嵌套在基类的作用域之内的（这就明白了为什么有时候子类中的成员函数会隐藏掉基类中函数，就时候如果我们想要使用被隐藏的基类函数，可以通过显示指明类名（这时可以理解为作用域名）来访问。
3. 在一个类的作用域中，编译器在解析类时，它总会先解析类中声明的所以数据成员与成员函数，再去解析成员函数的定义。正因为这样的原因，无论数据成员定义在成员函数的后面还是前面，还是成员函数的顺序前后之类的， 一个成员函数总是可以找到该类的数据成员或调用其它成员函数。

基于作用域的一个例子：

 // 程序
 class Base
 {
  public:
     virtual void Hello() { cout << "Hello, I am Base!" << endl; }
     void Hi() { cout << "Hi, Hi, Base!" << endl;}
 };

 class Derived : public Base
 {
 public:
     void Hello() override { cout << "Hello, I am Derived!" << endl;}
     void Hi() { cout << "Hi, Hi, Derived!" << endl;}
 };

 int main()
 {
     Derived Derive;
     Derive.Hello();
     Derive.Hi();
     Derive.Base::Hello();        //显示调用基类的虚函数
     Derive.Base::Hi();            // 显示调用基类普通函数

     Base *pBase = &Derive;
     pBase->Hello();        //指针调用，进行动态绑定，即多态
     pBase->Base::Hello();     //显示调用基类的虚函数
     pBase->Base::Hi();          // 显示调用基类普通函数

     return ;
 }

 //程序输出：
 Hello, I am Derived!
 Hi, Hi, Derived!
 Hello, I am Base!
 Hi, Hi, Base!
 Hello, I am Derived!
 Hello, I am Base!
 Hi, Hi, Base!

额外小知识点：

1. 待后续遇到补充！