C++教程-C++继承

C++继承

在C++中，继承是一个对象自动获得其父对象的所有属性和行为的过程。通过继承，您可以重用、扩展或修改在其他类中定义的属性和行为。

在C++中，继承了另一个类的成员的类被称为派生类，被继承成员的类被称为基类。派生类是基类的特殊化类。

C++继承的优点

代码重用性：现在您可以重用父类的成员。因此，不需要再次定义成员。因此，类中所需的代码更少。

继承的类型

C++支持五种类型的继承：

单继承
多重继承
分层继承
多级继承
混合继承

派生类

派生类定义为从基类派生的类。

派生类的语法：

class 派生类名 : 访问修饰符 基类名 
{ 
// 派生类的主体。
}

其中，

派生类名：派生类的名称。

访问修饰符：访问修饰符指定基类的特征是公开继承还是私有继承。它可以是public或private。

基类名：基类的名称。

当基类被私有继承时，基类的公共成员成为派生类的私有成员。因此，派生类的对象不能访问基类的公共成员，只能通过派生类的成员函数来访问。
当基类被公开继承时，基类的公共成员也成为派生类的公共成员。因此，派生类的对象以及基类的成员函数都可以访问基类的公共成员。

注意：

在C++中，可见性的默认模式是私有。
基类的私有成员永远不会被继承。

C++单继承

单继承被定义为派生类只从一个基类继承的继承。

其中'A'是基类，'B'是派生类。

C++单级继承示例：

继承字段当一个类继承另一个类时，它被称为单级继承。让我们看一个只继承字段的单级继承的示例。

#include <iostream>
using namespace std;
class Account {
public:
float salary = 60000;
};
class Programmer: public Account {
public:
float bonus = 5000;
};
int main(void) {
Programmer p1;
cout<<"Salary: "<<p1.salary<<endl;
cout<<"Bonus: "<<p1.bonus<<endl;
return 0;
}

输出：

Salary: 60000 
Bonus: 5000

在上面的示例中，Employee是基类，Programmer是派生类。

C++单级继承示例：继承方法

让我们看另一个C++中的继承示例，该示例仅继承方法。

#include <iostream>
using namespace std;
class Animal {
public:
void eat() {
cout<<"Eating..."<<endl;
}
};
class Dog: public Animal
{
public:
void bark(){
cout<<"Barking...";
}
};
int main(void) {
Dog d1;
d1.eat();
d1.bark();
return 0;
}

输出：

Eating... 
Barking...

让我们来看一个简单的例子。

cppCopy code
#include <iostream>  
using namespace std;  
class A  
{  
    int a = 4;  
    int b = 5;  
    public:  
    int mul()  
    {  
        int c = a*b;  
        return c;  
    }     
};  
  
class B : private A  
{  
    public:  
    void display()  
    {  
        int result = mul();  
        std::cout <<"Multiplication of a and b is : "<<result<< std::endl;  
    }  
};  
int main()  
{  
   B b;  
   b.display();  
  
    return 0;  
}

输出：

cssCopy code
Multiplication of a and b is : 20

在上面的例子中，类A被私有继承。因此，类B的对象无法访问类A的mul()函数。只有类B的成员函数才能访问它。

如何使私有成员可继承

私有成员是不可继承的。如果我们将其可见性更改为public，这就取消了数据隐藏的优势。

C++引入了第三种可见性修饰符，即protected。声明为protected的成员将可以在类内的所有成员函数以及直接派生自它的类中访问。

可见性修饰符可以分为三类：

Public：当成员声明为public时，它可被程序中的所有函数访问。
Private：当成员声明为private时，它只能在类内部访问。
Protected：当成员声明为protected时，它既可以在自身类内部访问，也可以在直接派生自它的类中访问。

继承成员的可见性

基类可见性	派生类可见性
	Public	Private	Protected
Private	不可继承	不可继承	不可继承
Protected	Protected	Private	Protected
Public	Public	Private	Protected

C++多层继承

多层继承是从一个派生类派生出另一个派生类的过程。

C++多层继承示例

当一个类继承另一个类，而后者又被另一个类继承时，在C++中称为多层继承。继承是传递的，因此最后一个派生类将继承所有基类的成员。

让我们看看C++中多层继承的示例。

#include <iostream>  
using namespace std;  
class Animal {  
   public:  
 void eat() {   
    cout<<"Eating..."<<endl;   
 }    
   };  
   class Dog: public Animal   
   {    
       public:  
     void bark(){  
    cout<<"Barking..."<<endl;   
     }    
   };   
   class BabyDog: public Dog   
   {    
       public:  
     void weep() {  
    cout<<"Weeping...";   
     }    
   };   
int main(void) {  
    BabyDog d1;  
    d1.eat();  
    d1.bark();  
     d1.weep();  
     return 0;  
}

输出：

Eating...
Barking...
Weeping...

C++多重继承

多重继承是从两个或更多类派生出一个新类的过程。

派生类的语法：

class D : 可见性 B-1, 可见性 B-2, ?
{
// 类的内容；
}

让我们看一个简单的多重继承的例子。

#include <iostream>  
using namespace std;  
class A  
{  
    protected:  
     int a;  
    public:  
    void get_a(int n)  
    {  
        a = n;  
    }  
};  
  
class B  
{  
    protected:  
    int b;  
    public:  
    void get_b(int n)  
    {  
        b = n;  
    }  
};  
class C : public A, public B  
{  
   public:  
    void display()  
    {  
        std::cout << "a的值为：" << a << std::endl;  
        std::cout << "b的值为：" << b << std::endl;  
        cout << "a和b的相加结果为：" << a + b;  
    }  
};  
int main()  
{  
   C c;  
   c.get_a(10);  
   c.get_b(20);  
   c.display();  
  
    return 0;  
}

输出：

a的值为：10
b的值为：20
a和b的相加结果为：30

在上面的例子中，类'C'以公有方式继承了两个基类'A'和'B'。

继承中的歧义解决

当在多重继承中两个或多个基类中出现同名函数时，会产生歧义。

通过以下示例来理解这一点：

#include <iostream>  
using namespace std;  
class A  
{  
    public:  
    void display()  
    {  
        std::cout << "类A" << std::endl;  
    }  
};  
class B  
{  
    public:  
    void display()  
    {  
        std::cout << "类B" << std::endl;  
    }  
};  
class C : public A, public B  
{  
    void view()  
    {  
        display();  
    }  
};  
int main()  
{  
    C c;  
    c.display();  
    return 0;  
}

输出：

错误：对'display'的引用不明确
        display();

可以通过使用类作用域运算符来解决上述问题。在上面的示例中，派生类代码可以重新编写为：

class C : public A, public B  
{  
    void view()  
    {  
        A::display();         // 调用类A的display()函数。  
        B::display();         // 调用类B的display()函数。  
    }  
};

在单继承中也可能出现歧义。

考虑以下情况：

class A  
{  
   public:  
void display()  
{  
   cout << "类A" << endl;  
}   
} ;  
class B  
{   
  public:  
 void display()  
{  
 cout << "类B" << endl;  
}  
} ;

在上述情况下，派生类的函数覆盖了基类的方法。因此，对display()函数的调用将简单地调用派生类中定义的函数。如果我们想调用基类函数，我们可以使用类作用域运算符。

int main()  
{  
    B b;  
   b.display();               // 调用B类的display()函数。  
   b.B :: display();       // 调用在B类中定义的display()函数。  
}

C++混合继承

混合继承是多种类型继承的组合。

让我们看一个简单的例子：

#include <iostream>  
using namespace std;  
class A  
{  
    protected:  
    int a;  
    public:  
    void get_a()  
    {  
       cout << "请输入'a'的值：" << endl;  
       cin>>a;  
    }  
};  
  
class B : public A   
{  
    protected:  
    int b;  
    public:  
    void get_b()  
    {  
        cout << "请输入'b'的值：" << endl;  
       cin>>b;  
    }  
};  
class C   
{  
    protected:  
    int c;  
    public:  
    void get_c()  
    {  
        cout << "请输入'c'的值：" << endl;  
        cin>>c;  
    }  
};  
  
class D : public B, public C  
{  
    protected:  
    int d;  
    public:  
    void mul()  
    {  
         get_a();  
         get_b();  
         get_c();  
         cout << "a、b、c的乘积为：" <<a*b*c<< endl;  
    }  
};  
int main()  
{  
    D d;  
    d.mul();  
    return 0;  
}

输出：

请输入'a'的值：
10              
请输入'b'的值：
20      
请输入'c'的值：
30  
a、b、c的乘积为：6000

C++分层继承

分层继承是从一个基类派生出两个或更多个类的过程。

分层继承的语法：

class A  
{  
    // 类A的内容。  
}    
class B : public A   
{  
    // 类B的内容。  
}  
class C : public A  
{  
    // 类C的内容。  
}   
class D : public A  
{  
    // 类D的内容。  
}