- 主要内容
- 继承的概念
- 继承的方式
- 类型兼容
继承的概念
继承是面向对象编程的核心概念之一，它允许我们基于现在的类（称为基类或父类）创建新的类（称为派生类或子类）。派生类自动获得基类的所有特性（属性与方法）。同时可以对其添加新的特性或修改继承带来的特性
class 派生类名 : 继承方式 基类名 {
// 派生类的成员定义
};一般是这种形式。
继承方式
C++提供了三种继承方式：
- public（公有继承）
- protected（保护继承）
- private（私有继承）
最常用的是公有继承，它保持了基类成员的访问权限。
这是一个简单的公有继承的办法
#include<iostream>
using namespace std;
//基类
class Person{
public:
string name;
int age;
void display(){
cout << "姓名: " << name << ",年龄" << age << endl;
}
};
//派生类
class Student : public Person{
public:
int studentID;
void study(){
cout << name << "正在学习" << endl;
}
};
int main()
{
Student s;
s.name = "张三";
s.age = 20;
s.studentID = 10001;
s.display();
s.study();
return 0;
}继承：派生类（子类）自动获得基类（父类）的属性和方法，避免重复编码。
基类：被继承的类
派生类：继承基类的类
class 派生类名 : 继承方式 基类名 {
// 新增成员或重定义基类成员
};
继承的方式：
#include<iostream>
using namespace std;
class Student{
public:
void setGrade(string name);
string getGrade();
void setName(string name);
string getName();
protected:
string _grade;
private:
string _name;
};
class Undergraduate : public Student
{
public:
Undergraduate(string major); //声明构造函数
void show();
private:
string _major;
};
void Student :: setGrade(string grade){
_grade = grade;
}
string Student::getGrade(){
return _grade;
}
void Student :: setName(string name){
_name = name;
}
string Student :: getName()
{
return _name;
}
Undergraduate::Undergraduate(string major){
_major = major;
}
void Undergraduate::show()
{
cout << "姓名" << getName() << endl;
cout << "年级" << _grade << endl;
cout << "专业:" << _major << endl;
}
int main()
{
Undergraduate stu("计算机信息工程"); //创建大学生类对象stu
stu.setGrade("大三"); //派生类对象调用基类成员函数设置年级
stu.setName("zhangsan"); //派生类对象调用基类成员函数设置姓名
stu.show(); //派生类对象调用新增成员函数显示学生信息
return 0;
}
基类的public成员在派生类中仍为public，可被外部访问。
保护继承：基类的public和protected成员在派生类中变为protected，只能被派生类及其子类访问。
私有继承：基类的public和protected成员在派生类中变为private，外部不可访问，子类也不可访问（仅限当前派生类使用）。
类型兼容
在公有继承下，派生类对象可当作基类对象使用，支持以下三种场景：
赋值兼容：派生类对象直接赋值给基类对象。
指针兼容：派生类对象的地址可赋给基类指针。
引用兼容：派生类对象可绑定到基类引用。
#include<iostream>
using namespace std;
class Base{
public:
Base();
void show();
protected:
string _name;
};
class Derive : public Base{
public:
Derive();
void display();
};
Base::Base() : _name("base") {}
void Base :: show(){
cout << _name << "Base show()" << endl;
}
Derive :: Derive() {_name = "derive";}
void Derive :: display(){
cout << _name << "Derive show()" << endl;
}
void func(Base* phase){
phase->show();
}
int main()
{
Derive derive;
Base base = derive;
Base& qbase = derive; //使用对象derive作为Base类对象的引用qbase赋值
Base* pbase = &derive;//使用对象derive作为Base类指针pbase赋值
base.show(); //通过base类对象调用show函数
qbase.show(); //通过base类对象引入调用
pbase->show(); //运用base类指针调用
func(&derive); //取对象derive的地址作为func()函数的参数
return 0;
}