C++中的继承

1.继承的概念及定义

继承 (inheritance) 机制是面向对象程序设计 使代码可以复用 的最重要的手段，它允许程序员在 保

持原有类特性的基础上进行扩展 ，增加功能，这样产生新的类，称派生类。继承 呈现了面向对象

程序设计的层次结构 ，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用， 继

承是类设计层次的复用 。说简单点就是一个A类具有的特性，另一个B类刚好具有A类的特性，此时这个B类就可以继承A类。可以看如下代码

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
//protected:
	string _name = "peter"; // 姓名
	int _age = 18;  // 年龄
};

// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，可以看到变量的复用。调用Print可以看到成员函数的复用。
class Student : public Person
{
protected:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};

int main()
{
	Person p;
	Student s;
	p.Print();
	s.Print();
	return 0;
}

运行结果：

1.2继承的定义

2.基类和派生类对象赋值转换

1.派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用 。这里有个形象的说法叫切片

或者切割。寓意把派生类中父类那部分切来赋值过去。

2.基类对象不能赋值给派生类对象。

3.基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类

的指针是指向派生类对象时才是安全的。

 

3.继承中的作用域  

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();
};

4.派生类的默认成员函数

6 个默认成员函数， “ 默认 ” 的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类

中，这几个成员函数是如何生成的呢？

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认

的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

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

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

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

保证派生类对象先清理派生类成员再清理基类成员的顺序。

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

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

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同 ( 这个我们后面会讲

解 ) 。那么编译器会对析构函数名进行特殊处理，处理成 destrutor() ，所以父类析构函数不加

virtual 的情况下，子类析构函数和父类析构函数构成隐藏关系。

如下代码会更好理解：

class Person
{
public:
	Person(const char* name = "Peter")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person &p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		if (this != &p)
		{
			_name = p._name;
		}
		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;

};

class Student :public Person
{
public:
	Student(const char* name = "lisi", int num = 0)
		:_num(num)
		, Person(name)//语法规定，初始化派生类
	{
		cout << "student()" << endl;
	}
	Student(const Student& s)
		:Person(s)//子类可以直接赋值给父类（剪切）p=s
		, _num(s._num)
	{
		cout << "Student(const Student &s)" << endl;
	}
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
		}
		return *this;
	}
	~Student()
	{
		cout << "~Student()" << endl;//写入子类的析构，保证先子后父
	}

protected:
	int _num;
	
};

int main()
{
	Person p("lisi");
	Person p1(p);

	Student s("张三",10);
	Student s1(s);

	Student s2("李四", 20);
	
	s1 = s2;

}

5.继承与友元

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

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);
}

6. 继承与静态成员

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

类，都只有一个 static 成员实例 。

7.复杂的菱形继承及菱形虚拟继承

关于这个数据冗余和二义性的问题，c++是通过虚拟继承来实现的，关于怎么实现的就是如下解决的，先看下面这段代码：

class A
{
public:
	int _a;
};

class B : virtual public A
{
public:
	int _b;
};

class C : virtual public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	d._a = 0;

	D d1;

	return 0;
}

int main()
{
	D d;
	d._a = 1;

	B b;
	b._a = 2;
	b._b = 3;

	B* ptr = &b;
	ptr->_a++;

	ptr = &d;
	ptr->_a++;

	return 0;
} 

上诉代码构成菱形继承，所以调试一下，

 

这时候我们看到B类中存储了一个指针，而那个指针指向的内容就是一个偏移量20，另一个就是12，在b的地址上加上偏移量就是a值的地址，c的地址加上12也是a的地址，所以这就是为什么a的值会变化，这样就解决了二义性的问题。

 

---

在过去的一年里，感谢我的好朋友小白和丹青的陪伴，希望在新的一年里，祝福我们万事如意，家人健康，平平安安，早日脱单哈。