【C++】继承和多态、public、private、protected、重写-Toy模板网

这篇具有很好参考价值的文章主要介绍了【C++】继承和多态、public、private、protected、重写。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

继承与多态的概念

	面向对象三大原则：封装、继承、多态。

继承是一种机制，通过它一个类可以从另一个类继承属性和方法。派生类（子类）继承基类（父类）的成员函数和数据成员，并且可以在其基础上扩展自己的成员函数和数据成员。C++支持多重继承，即一个派生类可以同时从多个基类中继承。
多态是指同一种操作作用于不同的对象上面，可以有不同的解释，产生不同的执行结果。在C++中，实现多态需要借助虚函数。虚函数是在基类中声明的函数，派生类可以对其进行重写，从而实现不同的功能。当通过指向基类的指针或引用调用虚函数时，程序会根据实际指向的对象类型来调用相应的函数，这种行为称为动态绑定，即在运行时确定调用的函数。

继承与多态的区别与联系

继承是指子类从父类继承属性和方法的过程，子类可以重写（override）父类的方法，以实现自己的特定功能。继承可以简化代码，减少重复的代码量，并且可以通过继承实现代码的复用。

多态是指同一种方法在不同对象上产生不同的行为。在多态的实现中，通常采用父类指针指向子类对象的方式，这样就可以通过父类指针调用子类方法，实现不同的行为。多态可以提高代码的灵活性和可扩展性，使得程序更易于维护和扩展。

区别：

继承是一种代码复用的方式，可以从父类继承属性和方法；多态则是一种代码执行的方式，同一个方法在不同对象上有不同的行为。
继承是一种静态的关系，类在编译时就确定了其继承关系；多态则是一种动态的关系，运行时才能确定具体的行为。
继承是一种自上而下的设计方式，父类是子类的模板；多态则是一种自下而上的设计方式，子类决定了父类的行为。

联系：

继承和多态都是面向对象编程的重要概念，它们都是实现代码复用、提高代码灵活性和可扩展性的重要方式。
多态需要继承作为前提，因为父类指针可以指向子类对象，才能实现多态的效果。

示例

#include <iostream>
using namespace std;

// 基类
class Shape {
   protected:
      int width, height;

   public:
      Shape( int a = 0, int b = 0) {
         width = a;
         height = b;
      }
      virtual int area() {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

// 派生类
class Rectangle: public Shape {
   public:
      Rectangle( int a = 0, int b = 0):Shape(a, b) { }

      int area () { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};

// 派生类
class Triangle: public Shape{
   public:
      Triangle( int a = 0, int b = 0):Shape(a, b) { }

      int area () { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};

int main( ) {
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);

   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();

   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}

结果：

【C++】继承和多态、public、private、protected、重写

可以看到，程序中定义了一个基类 Shape 和两个派生类 Rectangle 和 Triangle，两个派生类公有继承基类的属性和方法，并且重写了基类的虚函数 area()。在 main() 函数中，首先创建了一个指向基类的指针 shape，然后将其分别指向 Rectangle 和 Triangle 对象。最后通过指针调用虚函数。shape指针两次调用area方法，但是由于该指针指向的是不同对象，他会根据对象的类型来输出不同的结果，这就是多态。

继承和访问的权限

在 C++ 中，类继承分为三种类型：public、protected 和 private。它们分别表示基类成员在派生类中的访问权限：

public 继承：基类中的 public 成员在派生类中仍然是 public 的，基类中的 protected 成员在派生类中仍然是 protected 的，基类中的 private 成员仍然是私有的，private成员不能被派生类访问。
protected 继承：基类中的 public 成员在派生类中变成 protected 的，基类中的 protected 成员在派生类中仍然是 protected 的，并且只能被他的派生类成员函数和友元函数所访问，基类中的 private 成员不能被派生类访问。
private 继承：基类中的 public 和 protected 成员在派生类中变成 private 的，基类中的 private 成员不能被派生类访问。

说明

class Base {
public:
    int a;
protected:
    int b;
private:
    int c;
};

class Derived1 : public Base {
    // a是public的，b是protected的，c不能访问
};

class Derived2 : protected Base {
    // a是protected的，b是protected的，c不能访问
};

class Derived3 : private Base {
    // a是private的，b是private的，c不能访问
};

示例：

#include <iostream>

using namespace std;

class Parent {
public:
    void publicMethod() {
        cout << "This is a public method of Parent class." << endl;
    }

protected:
    void protectedMethod() {
        cout << "This is a protected method of Parent class." << endl;
    }

private:
    void privateMethod() {
        cout << "This is a private method of Parent class." << endl;
    }
};

class Child : public Parent {
public:
    void callParentMethods() {
        publicMethod();     // 公有方法可以在子类中直接访问
        protectedMethod();  // 保护方法可以在子类中直接访问
        // privateMethod();    // 私有方法不能在子类中直接访问
    }
};

int main() {
    Child childObj;
    childObj.publicMethod();     // 公有方法可以在子类对象中直接访问
    // childObj.protectedMethod();  // 保护方法不能在子类对象中直接访问
    // childObj.privateMethod();    // 私有方法不能在子类对象中直接访问

    childObj.callParentMethods(); // 子类中的方法可以调用父类的公有和保护方法

    return 0;
}

在这个示例程序中，Parent类有三个成员方法，分别为publicMethod()、protectedMethod()和privateMethod()，它们的访问权限分别为public、protected和private。Child类继承了Parent类，并在其中定义了一个方法callParentMethods()，用于调用Parent类的publicMethod()和protectedMethod()方法。在main函数中，我们创建了一个Child类的对象childObj，并演示了不同的访问方式和权限。