【C++】-初步认识和学习继承
作者：小树苗渴望变成参天大树
作者宣言：认真写好每一篇博客
作者gitee:gitee✨
作者专栏：C语言,数据结构初阶,Linux,C++ 动态规划算法
如 果 你 喜 欢 作 者 的 文 章 ，就 给 作 者 点 点 关 注 吧！
文章目录
- 前言
- 一、继承的概念及定义
-
- 1.1继承的概念
- 1.2继承定义
- 二.基类和派生类对象赋值转换
- 三.继承中的作用域
-
- 3.1成员变量的作用域
- 3.2成员函数的作用域
- 四、派生类的默认成员函数
- 五、继承与友元
- 六、 继承与静态成员
- 七、总结
前言
今天开始我们就开始学习我们C++的进阶部分，我们今天学习的第一个知识就是继承，我把不难理解的一部分放到这篇博客里面，目的是为了让大家先入门一下，等到菱形继承的时候，我在详细介绍一下，这样大家的接受也会好一点，话不多说，我们开始进入正文了。
本篇重点
- 继承的概念及定义
- 基类和派生类对象赋值转换
- 继承中的作用域
- 派生类的默认成员函数
- 继承与友元
- 继承与静态成员
一、继承的概念及定义
1.1继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用
我们来看示例：
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter"; // 姓名
int _age = 18; // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了
//Student和Teacher复用了Person的成员。
class Student : public Person
{
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Person p;
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}
我们看看对象在内存当中是怎么存储的：
通过看大小我们也理解我们的继承的目的了，虽然占用空间大小和不继承的是一样的，但是解决了写代码的时候数据看上去冗余的效果。并且我们的函数也是继承下来了，也是可以使用。（类的计算不算函数的大小）
通过上面的代码和监视，我们知道了继承的样子和继承后的效果，那我们正式来看看继承
1.2继承定义
上面我们看到Person是父类，也称作基类。Student是子类，也称作派生类
接下来我们就来看看继承方式：
访问限定符：
先给大家说明我们实际开发中，几乎用的都是public继承，protected和private继承几乎不用
继承方式和访问限定符决定了我们有什么权限去访问基类的成员
我们来看一张表:
总结：
-
基类private成员在派生类中无论以什么方式继承都是不能被派生类访问的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
-
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
-
实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected >private。,但是你测试一下会发现，不管是共有继承还是保护继承，共有和保护成员都是可以在子类访问到的,没啥差距的
-
使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。使用private的继承方式，那么此类下面的子类就不能访问到此类的基类中的任何成员了
-
在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承， 也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强，类中的成员变量推荐使用保护，函数使用共有
相信大家对继承方式和访问限定符对于继承中访问父子类成员的效果应该都理解了吧。
二.基类和派生类对象赋值转换
这个博主需要画图来给大家进行讲解
-
派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
-
基类对象不能赋值给派生类对象。
等一会讲派生类的默认成员函数的时候就知道，我们只可以这么理解：基类赋值给子类对象的时候，不是赋值就是拷贝构造，这样就没有给子类特有成员进行处理，子类对象赋值给父类的可以，可以调用父类的构造函数或者赋值运算符，因为父类的成员子类肯定都有。 -
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast来进行识别后进行安全转换。（这个我们后面再讲解，这里先了解一下）
Student sobj;
Person*pp=&sobj;
Student*ps1= (Student*)pp; // 这种情况转换时可以的。
Person& pp=sobj
Student ps1= (Student)pp; // 这种情况转换时可以的。
Person pobj ;
Person*pp=&pobj;
Student*ps1= (Student*)pp; // 这种情况转换可能出错
Person& pp=pobj
Student ps1= (Student)pp;// 这种情况转换可能出错。
三.继承中的作用域
3.1成员变量的作用域
在继承体系中基类和派生类都有独立的作用域。所以遇到同名的时候，语法是正确的
// 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();
};
子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。想要访问父类的就需要指定类域
3.2成员函数的作用域
// 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)
{
cout << "func(int i)->" <<i<<endl;
}
};
void Test()
{
B b;
b.fun();//此处会报错，它再子类找到fun了但是是需要传参数，你没有传就会出现错误
b.A::fun();//通过指定类域就可以取访问父类的同名函数
};
如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
四、派生类的默认成员函数
我们不管是派生类还是基类，都是类，是类都有之前说到溜达默认成员函数，因为有两种不重要，今天我们就看其中四种，我们使用继承后，大部分是使用子类创建对象，那么我们必然会使用到成员函数，子类是继承父类的属性，所以子类再使用默认成员函数的时候，也要考虑到父类的成员，虽然子类可以访问到父类的成员，但是祖师爷想的是，每个类去完成自己的事就可以了，我们来看：
class Person
{
public :
Person(const char* name = "peter")
: _name(name )
{
cout<<"Person()" <<endl;
}
Person(const Person& p)
: _name(p._name)
{}
Person& operator=(const Person& p )
{
cout<<"Person operator=(const Person& p)"<< endl;
if (this != &p)
_name = p ._name;
return *this ;
}
~Person()
{
cout<<"~Person()" <<endl;
}
protected :
string _name ; // 姓名
};
class Student : public Person
{
public :
Student(const char* name, int num)
: Person(name )//需要去调用父类的构造函数完成初始化
, _num(num )
{
cout<<"Student()" <<endl;
}
Student(const Student& s)
: Person(s)//先完成父类的拷贝
, _num(s ._num)//再完成自己的拷贝
{
cout<<"Student(const Student& s)" <<endl ;
}
Student& operator = (const Student& s )
{
cout<<"Student& operator= (const Student& s)"<< endl;
if (this != &s)
{
Person::operator =(s);//必须指定类域，不然会隐藏父类的赋值运算符，造成栈溢出
_num = s ._num;
}
return *this ;
}
~Student()
{
cout<<"~Student()" <<endl;
}
protected :
int _num ; //学号
};
void Test ()
{
Student s1 ("jack", 18);
Student s2 (s1);
Student s3 ("rose", 17);
s1 = s3 ;
}
- 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用父类的构造函数。
- 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
- 派生类的operator=必须要调用基类的operator=完成基类的复制。
析构函数重点说一下：
我们发现其他三个函数再子类的函数都去调用了父类的函数了，而析构函数去没有，这是为什么呢？？
派生类对象初始化先调用基类构造再调派生类构造。
派生类对象析构清理先调用派生类析构再调基类的析构。
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
这样做的好处是，防止你在析构父类后，又去访问父类里面的成员，而把子类先析构干净再析构父类的比较好，因为子类会使用父类里面的成员，而父类则不会使用子类的。
看结果：
五、继承与友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
class Student;
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
public:
friend void Display(const Person& p, const Student& s);//这样就可以了
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;
}
七、总结
我们今天的继承就讲解到这里了，相信大家对继承的应该有所收获了吧，今天讲的都不难，下一篇开始上强度了，我们下篇再见
