C++进阶：继承

Posted 2021-08-17 银背欧尼酱

文章目录

• 前言
• 一、继承的概念和定义
• • 1.1继承的概念
  • 1.2 继承方式和访问限定符
  • 小结
• 二、基类和派生类对象赋值转换
• 三，继承中的作用域
• 四，派生类的默认成员函数
• 五，继承与友元，静态
• 六，菱形继承以及菱形虚拟继承
• 总结

---

前言

本篇文章介绍什么是继承，继承是C++语法中的核心部分，无论是实际应用和面试找工作都是重点内容。希望大家重视起来。

---

一、继承的概念和定义

1.1继承的概念

继承机制是面向程序设计时使代码复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触到的复用都是函数复用，继承是类设计层次的复用。

class Person
{
public:
     void Print()
     {
         cout << "name:" << name << endl;
         cout << "age:" << age << endl;
     }
protected:
     string name = "bidelovec"; // 姓名
     int age = 18; // 年龄
};
//    派生类     继承方式  基类
class Student : public Person
{
protected:
     int stuid; // 学号
};
class Teacher : public Person
{
protected:
     int jobid; // 工号
};
int main()
{
     Student stu;
     Teacher tea;
     stu.Print();
     tea.Print();
     return 0; 
 }

1.2 继承方式和访问限定符

小结

1. 基类private成员在派生类中无论以什么样的方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里还是类外都不能访问private成员。
2. 基类private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出protected限定符是因为继承才出现的。
3. 使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
4. 实际运用时一般使用都是public继承，几乎很少使用protected/private继承，也不提倡。因为protected/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

二、基类和派生类对象赋值转换

1. 派生类对象（子类）可以赋值给基类的对象/基类的指针/基类的引用。但是基类的对象不能赋值给派生类对象。

2. 基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。

class Person
{
protected :
     string name; // 姓名
     string sex; // 性别
     int age; // 年龄
};
class Student : public Person
{
public :
     int No ; // 学号
};

void Test ()
{
     Student sobj ;
     // 1.子类对象可以赋值给父类对象/指针/引用
     Person pobj = sobj ;
     Person* pp = &sobj;
     Person& rp = sobj;

     //2.基类对象不能赋值给派生类对象
     sobj = pobj;

     // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
     pp = &sobj
     Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
     ps1->No = 10;

     pp = &pobj;
     Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
     ps2->No = 10;
}

三，继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。

2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）

3. 如果是成员函数的隐藏，只需要函数名就构成隐藏。

4. 实际中在继承体系里面最好不要定义同名的成员。

// Student的num和Person的num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
protected :
 string name = "小李子"; // 姓名
 int num = 111; // 身份证号
};
class Student : public Person
{
public:
 void Print()
 {
 cout<<" 姓名:"<<name<< endl;
 cout<<" 身份证号:"<<Person::num<< endl;
 cout<<" 学号:"<<num<<endl;
 }
protected:
 int num = 999; // 学号
};
void Test()
{
 Student s1;
 s1.Print();
};

// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A {
public:
     void fun()
     {
         cout << "func()" << endl;
     }
};
class B : public A {
public:
     void fun(int i)
     {
         A::fun();
         cout << "func(int i)->" <<i<<endl;
     }
};
    void Test()
    {
         B b;
         b.fun(10);
    };

四，派生类的默认成员函数

1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

2.派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类的拷贝初始化。

3.派生类的operator=必须要调用基类的operator=完成基类的复制

4.派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员。

5.派生类对象初始化先调用基类构造再调派生类构造。

6.派生类对象析构清理先调用派生类析构再调基类的析构。

五，继承与友元，静态

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

class Student;
class Person
{
public:
     friend void Display(const Person& p, const Student& s);
protected:
     string name; // 姓名
};
class Student : public Person
{
protected:
     int stuNum; // 学号
};
void Display(const Person& p, const Student& s) 
{
     cout << p.name << endl;
     cout << s.stuNum << endl; 
}
void main()
{
     Person p;
     Student s;
     Display(p, s);
}

基类定义了static静态成员，则整个继承体系里只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。

class Person
{
public :
 Person () 
 {
 	++ count ;
 }
protected :
     string name ; // 姓名
public :
     static int count; // 统计人的个数。
};
int Person :: count = 0;
class Student : public Person
{
protected :
     int stuNum ; // 学号
};
class Graduate : public Student
{
protected :
     string seminarCourse ; // 研究科目
};
void TestPerson()
{
     Student s1 ;
     Student s2 ;
     Student s3 ;
     Graduate s4 ;
     cout <<" 人数 :"<< Person ::count << endl;
     Student ::count = 0;
     cout <<" 人数 :"<< Person ::count << endl; 
 }

六，菱形继承以及菱形虚拟继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承。

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承：菱形继承是多继承的一种特殊情况

菱形继承的问题：菱形继承有数据应冗余和二义性的问题。

class Person
{
public :
     string name ; // 姓名
};

class Student : public Person
{
protected :
     int num ; //学号
};
class Teacher : public Person
{
protected :
     int id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected :
     string majorCourse ; // 主修课程
};
void Test ()
{
     // 这样会有二义性无法明确知道访问的是哪一个
     Assistant a ;
     a.name = "peter";

     // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
     a.Student::name = "xxx";
     a.Teacher::name = "yyy"; 
 }

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

class Person
{
public :
	 string name ; // 姓名
};
class Student : virtual public Person
{
protected :
	 int num ; //学号
};
class Teacher : virtual public Person
{
protected :
	 int id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected :
	 string majorCourse ; // 主修课程
};
void Test ()
{
	 Assistant a ;

---

现在主要从：

1.基类成员对其对象的可见性：
2. 基类成员对派生类的可见性：
3. 基类成员对派生类对象的可见性：

#include <iostream>
 
class base{
public:
	base(){
		a = 0;
		b = 1;
		c = 2;
	}
	int a;
protected:
	int b;
private:
	int c;
};
 
class derived1 : public base{//public继承
public:
	void fun(){//derived class可以访问public和protected member
		std::cout<<base::a<<base::b<<std::endl;
	//	std::cout<<base::c;//不能访问
	}
};
class derived2 : protected base{//protected继承
public:
	void fun(){//derived class可以访问public和protected member
		std::cout<<base::a<<base::b<<std::endl;
	 // std::cout<<base::c;//不能访问
	}
};
class derived3 : private base{//private继承
public:
	void fun(){//derived class可以访问public和protected member
		std::cout<<base::a<<base::b<<std::endl;
	 // std::cout<<base::c;//不能访问
	}
};
class derived4 : public derived3{//base的member不能被private继承的派生类的子类访问
public:
	void fun(){
	//	std::cout<<a;
	}
};
class derived5 : base{//默认private继承
	void fun(){//derived class可以访问public和protected member
		std::cout<<base::a<<base::b;
		// std::cout<<base::c;//不能访问
	}	
};
int main(void)
{
	base b1;
	derived1 d1;
	derived2 d2;
	derived3 d3;
	d1.fun();
	d2.fun();
	d3.fun();
	std::cout<<b1.a;//base class Object只能访问public member
	std::cout<<d1.a;//public继承时 derived class Object只能访问base class的public member
	//std::cout<<d1.b<<d1.c;//不能访问
	//std::cout<<d2.a<<d2.b;//protected继承时 derived class Object不能问访base class的member
	//std::cout<<d3.a;//private继承时 derived class Object不能问访base class的member
	return 0;
}

总结

以上就是今天的内容，介绍了继承，单继承，多继承，菱形继承等。以上就是今天的内容，希望大家有所收获。