📌  相关文章
📜  C++继承

📅  最后修改于: 2020-09-25 04:57:55             🧑  作者: Mango

在本教程中，我们将借助示例学习C++中的继承。

继承是C++中面向对象编程的主要功能之一。它允许我们从现有类(基类)创建一个新类(派生类)。

派生类从基类继承要素，并且可以拥有自己的附加要素。例如， 

class Animal {
    // eat() function
    // sleep() function
};

class Dog : public Animal {
    // bark() function
};

这里， Dog类是从Animal类派生的。由于Dog是源自Animal的成员， Animal是可访问的Dog 。

请注意，从Animal继承Dog时使用了关键字public 。 

class Dog : public Animal {...};

我们还可以使用关键字private和protected代替public 。在本教程的后面，我们将学习使用private ， public和protected之间的区别。

是关系

继承是一种关系 。仅在两个类之间存在is-a关系时才使用继承。

这里有些例子：

示例1：C++继承的简单示例

// C++ program to demonstrate inheritance

#include 
using namespace std;

// base class
class Animal {

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }
};

// derived class
class Dog : public Animal {
 
   public:
    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();

    // Calling member of the derived class
    dog1.bark();

    return 0;
}

输出 

I can eat!
I can sleep!
I can bark! Woof woof!!

在这里， dog1 (派生类Dog的对象)可以访问基类Animal成员。这是因为Dog继承自Animal 。 

// Calling members of the Animal class
dog1.eat();
dog1.sleep();

受C++保护的成员

当涉及C++继承时， protected的访问修饰符尤其重要。

与private成员一样， protected成员在课堂之外也无法访问。但是， 派生类和朋友类/函数可以访问它们。

如果我们想隐藏一个类的数据，但仍希望该数据被其派生类继承，则需要protected成员。

要了解有关受保护的更多信息，请参阅我们的C++访问修饰符教程。

示例2：受C++保护的成员

// C++ program to demonstrate protected members

#include 
#include 
using namespace std;

// base class
class Animal {

   private:
    string color;

   protected:
    string type;

   public:
    void eat() {
        cout << "I can eat!" << endl;
    }

    void sleep() {
        cout << "I can sleep!" << endl;
    }

    void setColor(string clr) {
        color = clr;
    }

    string getColor() {
        return color;
    }
};

// derived class
class Dog : public Animal {

   public:
    void setType(string tp) {
        type = tp;
    }

    void displayInfo(string c) {
        cout << "I am a " << type << endl;
        cout << "My color is " << c << endl;
    }

    void bark() {
        cout << "I can bark! Woof woof!!" << endl;
    }
};

int main() {
    // Create object of the Dog class
    Dog dog1;

    // Calling members of the base class
    dog1.eat();
    dog1.sleep();
    dog1.setColor("black");

    // Calling member of the derived class
    dog1.bark();
    dog1.setType("mammal");

    // Using getColor() of dog1 as argument
    // getColor() returns string data
    dog1.displayInfo(dog1.getColor());

    return 0;
}

输出 

I can eat!
I can sleep!
I can bark! Woof woof!!
I am a mammal
My color is black

此处，变量type protected ，因此可以从派生类Dog访问。我们可以通过使用setType() 函数在Dog类中初始化type ，从而看到这一点。

另一方面， private变量color无法在Dog初始化。 

class Dog : public Animal {

    public:
      void setColor(string clr) {
          // Error: member "Animal::color" is inaccessible
          color = clr; 
      }
};

另外，由于protected关键字隐藏了数据，因此我们无法直接从Dog或Animal类的对象访问type 。 

// Error: member "Animal::type" is inaccessible
dog1.type = "mammal";

C++继承中的访问模式

在以前的教程中，我们了解了C++访问说明符，例如public，private和protected。

到目前为止，我们已经使用public关键字来从以前存在的基类中继承一个类。但是，我们也可以使用private和protected关键字来继承类。例如， 

class Animal {
    // code
};

class Dog : private Animal {
    // code
};
class Cat : protected Animal {
    // code
};

我们获得类的各种方法称为访问模式 。这些访问模式具有以下效果：

基类的private成员在派生类中始终是private的。

要了解更多信息，请访问我们的C++公共，私有，受保护继承教程。

继承中的成员函数重写

假设基类和派生类的成员函数具有相同的名称和参数。

如果我们创建派生类的对象并尝试访问该成员 函数，则将调用派生类中的成员 函数 ，而不是基类中的成员 函数 。

派生类的成员 函数重写基类的成员 函数 。

了解有关C++中的函数重写的更多信息。

推荐读物： C++多重继承