前言
此篇我们来初步探讨一下继承的相关知识，欢迎大家和我一起学习，共同进步
一、继承的概念及定义
1.继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
简单来说就是子类继承父类后，可以使用父类的成员或者函数（前提是访问权限足够，这个我们后面讲）
父类（基类）：父类是一个更一般、更抽象的类，它定义了一组属性和方法，这些属性和方法会被其子类所继承。父类通常用于表示一种广泛的、更通用的概念或对象
子类（派生类）：子类是一个更具体、更特殊的类，它继承了父类的属性和方法，并可以添加新的属性或 覆盖(重写) 父类的方法。子类通常用于表示一种更具体、更特殊的概念或对象，这些对象属于父类所定义的广泛类别中的一部分
举例说明：
看这个图就比较通俗了，不管是学生，老师还是保安，他们都具备人的特性，都有姓名，性别，年龄……，所以他们都可以继承Person类作为父类，而他们则是Person的子类（派生类），派生类可以有和父类不一样的其他特性（成员）或者方法
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter";// 姓名
int _age = 18; //年龄
};
class Student:public Person
{
protected:
int _stuid; //学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Student s;
s.Print();//调用父类的方法
Teacher t;
t.Print();
return 0;
}
继承后父类Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出Student和Teacher复用了Person的成员
2.继承的定义
2.1、定义格式
2.2、继承关系和访问限定符
2.3、继承基类成员访问方式的变化
①基类的private成员在派生类中无论以什么方式继承，都是不可见的，不可见不代表没有继承，这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter";// 姓名
private:
int _age = 18; //年龄
};
class Student:public Person
{
protected:
int _stuid; //学号
};
int main()
{
Student s;
s.Print();//虽然我们不能直接访问父类里面的私有成员，但是我们可以通过Print()间接访问
return 0;
}
②基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的
父类/基类
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter";// 姓名
private:
int _age = 18; //年龄
};
子类/派生类
class Student:public Person
{
public:
void sp()
{
_name="ok";//父类中的保护成员可以在子类中访问
Print();
}
protected:
int _stuid; //学号
};
int main()
{
Student s;
//s._name;父类中的保护成员不能在类外面使用，不然会报错---Student中没有_name成员
return 0;
}
③实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private
通俗来说就是父类的成员在子类中的访问方式=取成员在父类中的访问限定符和继承方式最小的那个
举例：
父类/基类
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter";// 姓名
private:
int _age = 18; //年龄
};
派生类/子类
注意我们这里使用的继承方式是保护(protected)
class Student:protected Person//注意我们这里的继承方式是保护
{
public:
void sp()
{
//针对父类的Print函数来说
//Print在父类是公共的(public)，min(public,protected),所以Print在子类的访问方式是protected
Print();//在子类可以访问
//针对父类的_name成员来说
//min(protected,protected),所以_name在子类的访问方式是protected
_name="ok";
//针对父类的_age成员来说
//min(private,protected),所以_age在子类发访问方式是private
//不能直接访问
}
protected:
int _stuid; //学号
};
④使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式
//struct Student:public Person
struct Student:Person//struct默认继承方式是public
{}
//class Student:private Person
class Student:Person//class默认继承方式是private
{}
举例：
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter";// 姓名
private:
int _age = 18; //年龄
};
class
//class T:private Person
class T : Person//class 的默认继承方式是私有
{
public:
void cp()
{
Print();
//Print本来在父类中是public，由于继承方式是私有，所以现在Print在子类的访问权限是private
//访问权限因为继承的关系而变成私有，不是本身在父类中是私有，所以是可以在类里面被访问的，不能在类外面访问
//注意别和父类中的私有成员那块搞混了
}
};
struct
//struct S:public Person
struct S :Person//struct 的默认继承方式是公共的
{
void sp()
{
_name = "okk";
//_age = 10;基类的私有成员在子类中不能直接访问
Print();
}
};
⑤在实际运用中一般使用都是public继承 几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
二、基类和派生类对象赋值转换
1.派生类对象可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
切片或切割
void test1()
{
Student s;
//切片/切割---赋值兼容（可以理解成编译器做了特殊处理）
Person p=s;//将子类对象赋值给父类对象，这里发生了切片
const string& str="111";//中间会产生临时对象，临时对象具有常性，要加const
Person& pref=s;//这里就不需要加const，这是继承这块特有的，中间不产生临时对象
Person* Ptr=&s;//将子类对象赋值给父类的指针，这里没有发生切片
}
什么是赋值兼容？
赋值兼容（Assignment Compatibility）通常指的是子类（派生类）对象可以赋值给基类（父类）对象的指针或引用，但反之则不然（即基类对象不能直接赋值给子类对象的指针或引用，除非使用显式的类型转换或某些特殊技术）。
将派生类赋值给父类，发生切片现象
可以这么理解：将子类中父类的成员单独放在一块，然后切出来拷贝赋值给父类，每个子类对象都是一个特殊的父类对象
将派生类对象赋值给基类指针
将
Student类型的对象s的引用（而不是值）赋值给一个Person类型的引用pref。这里并没有发生隐式转换或创建临时对象。相反，你正在创建一个引用，该引用直接指向已经存在的s对象（但只通过其 Person 部分进行访问）。
将派生类对象赋值给基类引用
将一个派生类对象赋值给基类引用时，实际上并没有进行任何复制或转换操作，而是让基类引用绑定到派生类对象的基类部分，不会发生切片现象
2.基类对象不能赋值给派生类对象。
3.基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTimeType Information)的dynamic_cast 来进行识别后进行安全转换。
三、继承中的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
- 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
- 注意在实际中在继承体系里面最好不要定义同名的成员
成员变量的隐藏
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; // 学号
};
Student s;
s.Print();
子类和父类中都有变量_num，容易混淆，降低了代码的可读性，在调用Print()函数时，两个_num的打印结果都是999，因为子类成员变量名和父类成员变量名相同时会出现隐藏现象，子类的_num将父类的_num覆盖掉了，所以打印身份证的时候无法正确打印，出现这种情况我们可以显示访问父类的_num，如：Person::_num
成员函数的隐藏
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
//fun();这样调用编译器会报错---fun()函数不接受0个参数
//fun()不是从A类里面继承下来的吗？为什么不能直接访问
cout << "func(int i)->" << i << endl;
}
};
父类的fun()和子类的fun(int i)函数名相同，构成隐藏，不能直接在子类中访问他，会报参数不匹配的问题，可以显示访问A::fun()
问题：A中的fun()和B中的fun(int i)难道不会构成重载吗？
解：他们两个不会构成重载，因为他们属于不同的作用域
下一篇我们接着来探讨继承里面其他的知识点，欢迎大家来指教哦📩
扫一扫
620
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
