C++类和对象特性（继承性，封装性，多态性）

继承性

基类&派生类定义及其基本定义

当创建一个新的类时，可以指定它继承已有的类的成员。这两个类分别被称为基类，派生类。

继承，就是将基类中public和protected中的成员，全部或分别，继承到派生类中的private、protected、public中，单个或多个部分中

派生类可以从一个或多个基类继承数据和函数，定义的形式如下

class namea:private nameb//继承单一基类的部分
{
}
class namea:private nameb,private namec//继承不同基类
{
}

其中访问修饰符private还可以是访问修饰符public,protected

注意：派生类并非继承全部成员，以下情况例外

• 基类的构造函数、析构函数和拷贝构造函数
• 基类的重载运算符。
• 基类的重载运算符。

访问控制和继承

需要注意的是：派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private

访问	public	protected	private
同一个类	yes	yes	yes
派生类	yes	yes	no
外部的类	yes	no	no

继承类型
当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型
不同类型的继承遵循以下的规则，即基类成员在派生类中的位置

公有继承

派生类	公有成员	保护成员	私有成员
基类	公有成员	保护成员	无

保护继承

派生类	公有成员	保护成员	私有成员
基类	无	公有和保护成员	无

私有继承

派生类	公有成员	保护成员	私有成员
基类	无	无	公有和保护成员

#include <iostream>
 
using namespace std;
 
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
 
   return 0;
}

多态性

当类之间存在层次结构，并且是通过继承关联时，就存在多态。

多态就是将子类类型的指针赋值给父类类型的指针，根据调用函数的对象的类型来执行不同的函数。

在实现多态的时候可以用到虚函数virtual

可以将基类A比作父亲，而派生类B,C比作孩子。当B，C继承了父亲A时，在某相同的基因片段（函数名）可能部分基因有所不同（函数的内容），这时候就体现了多态性。
下面是一段代码示例

class A
{
public:
    virtual void foo()
    {
        cout<<"This is A."<<endl;
    }
};
 
class B: public A
{
public:
    void foo()
    {
        cout<<"This is B."<<endl;
    }
};
 
int main(int argc, char *argv[])
{
    A *a = new B();
    a->foo();
    return 0;
}

输出的结果为This is B.而当去掉virtual 后输出的是This is A.

基类的函数取决于子类的函数，类似函数指针调用，这样就能通过一个接口实现多个功能

封装性

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用

C++ 通过创建类来支持封装，在使用类的时候应该用到了这一特性
数据封装的同时又会伴随着数据抽象，对外公开类中的函数而隐藏数据
下面举个例子

class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};

在该代码中，Shape类向外界提供了setwidth和setHeight两个方法，但是隐藏了widht和height两个数据

对外提供了接口，就像一个机器，你只需要知道怎么用，但却不必知道内部怎么运作。你只看到机器的外表，内部却有很多看不到的部件


总而言之呢三个特性都是基于类与对象的，前者是基础，而这三个特性只是延申*，应当着重看基础部分。
封装和多态都好抽象啊…

部分实例来自https://www.runoob.com/cplusplus/cpp-tutorial.html