做图网站有哪些内容,做注册会计师网站,软件外包公司如何找客户,html编辑器文字居中文章目录 继承的概念继承的定义继承方式和访问限定符继承基类成员访问方式的变化 默认继承方式 基类和派生类对象赋值转换继承中的作用域派生类的默认成员函数继承与友元静态成员菱形继承及菱形虚拟继承继承的方式 菱形虚拟继承菱形虚拟继承原理 继承的概念
继承(inheritance)… 文章目录 继承的概念继承的定义继承方式和访问限定符继承基类成员访问方式的变化 默认继承方式 基类和派生类对象赋值转换继承中的作用域派生类的默认成员函数继承与友元静态成员菱形继承及菱形虚拟继承继承的方式 菱形虚拟继承菱形虚拟继承原理 继承的概念
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段它允许程序员在保持原有类特性的基础上进行扩展增加功能这样产生新的类称派生类。继承呈现了面向对象程序设计的层次结构体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用继承是类设计层次的复用
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;Teacher t;s.Print();t.Print();return 0;
}继承后父类Person的成员包括成员函数和成员变量都会变成子类的一部分也就是子类Student和Teacher复用了父类Person的成员。
继承的定义
Person是父类也称作基类。Student是子类也称作派生类 继承方式和访问限定符
访问限定符有以下三种public访问、protected访问、private访问
继承的方式也有类似的三种public继承、protected继承、private继承
继承基类成员访问方式的变化
基类当中被不同访问限定符修饰的成员以不同的继承方式继承到派生类当中后该成员最终在派生类当中的访问方式将会发生变化。 总结
基类private成员在派生类中无论以什么方式继承都是不可见的。 这里所说的不可见从语法上限制访问(类里面和类外面都不能用)。 跟private访问限定符不一样private访问限定符类外面不能使用类里面可以使用
//基类
class Person
{
private:string name 张三;
};
//派生类
class Student :public Person
{
public:void Print(){//在派生类当中访问基类的private成员cout _name endl;//error}
protected:int _stuid; // 学号
};上述代码中 Student类继承了Person类但是无法在Student类当中访问Person类当中的private成员_name。如果需要在派生类中能访问就将private修改为protected 基类private成员在派生类中是不能被访问如果基类成员不想在类外直接被访问但需要在派生类中能访问就定义为protected。可以看出保护成员限定符是因继承才出现的。 实际上面的表格我们进行一下总结会发现基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 Min(成员在基类的访问限定符继承方式)public protected private。 使用关键字class时默认的继承方式是private使用struct时默认的继承方式是public不过最好显示的写出继承方式。 在实际运用中一般使用都是public继承几乎很少使用protetced/private继承也不提倡使用protetced/private继承因为protetced/private继承下来的成员都只能在派生类的类里面使用实际中扩展维护性不强
默认继承方式
在使用继承的时候也可以不指定继承方式使用关键字class时默认的继承方式是private使用struct时默认的继承方式是public。
//基类
class Person
{
public:string _name 张三; //姓名
};
//派生类
class Student : Person //默认为private继承
{
protected:int _stuid; //学号
};
在关键字为class的派生类当中所继承的基类成员_name的访问方式变为private。
//基类
class Person
{
public:string _name 张三; //姓名
};
//派生类
struct Student : Person //默认为public继承
{
protected:int _stuid; //学号
};
在关键字为struct的派生类当中所继承的基类成员_name的访问方式仍为public。
基类和派生类对象赋值转换
派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
//基类
class Person
{
public:string _name; //姓名string _sex; //性别int _age; //年龄
};//派生类
class Student : public Person
{
protected:int _stuid; //学号
};int main()
{Student s;Person p s; //派生类对象赋值给基类对象Person* ptr s;//派生类对象赋值给基类指针Person ref s; //派生类对象赋值给基类引用return 0;
}派生类对象赋值给基类对象图示 注意基类对象不能赋值给派生类对象。
继承中的作用域
在继承体系中的基类和派生类都有独立的作用域。如果子类和父类中有同名成员子类成员将屏蔽父类对同名成员的直接访问这种情况叫隐藏也叫重定义
例如
//父类
class Person
{
protected:int _num 111;
};
//子类
class Student : public Person
{
public: void fun(){cout _num endl;}
protected:int _num 999;
};
int main()
{Student s;s.fun();//访问子类的_numreturn 0;
}如果需要访问父类当中的_num成员使用作用域限定符进行指定访问。
//父类
class Person
{
protected:int _num 111;
};
//子类
class Student : public Person
{
public: void fun(){cout Person::_num endl;}
protected:int _num 999;
};
int main()
{Student s;s.fun();//访问子类的_numreturn 0;
}下面的代码调用成员函数fun时将调用子类当中的fun如果需要调用父类当中的fun则使用作用域限定符指定类域。
//父类
class Person
{
public:void fun(int x){cout x endl;}
};
//子类
class Student : public Person
{
public:void fun(double x){cout x endl;}
};
int main()
{Student s;s.fun(3.14); //直接调用子类当中的成员函数funs.Person::fun(20); //指定调用父类当中的成员函数funreturn 0;
}
上述代码父类中的fun和子类中的fun不是构成函数重载构成函数重载需要两个函数在同一作用域而此时这两个fun函数并不在同一作用域。为了避免类似问题实际在继承体系当中最好不要定义同名的成员。
隐藏 父子类域中成员函数的函数名相同就构成隐藏不用管函数参数只需要看函数名即可
派生类的默认成员函数
默认成员函数即我们不写编译器会自动生成的函数类当中的默认成员函数有以下六个 //基类
class Person
{
public://构造函数Person(const string 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){cout Person operator(const Person p) endl;if (this ! p){_name p._name;}return *this;}~Person(){cout ~Person() endl;}
private:string _name;
};//派生类
class Student : public Person
{
public://默认构造函数//先父后子Student(const string name 张三, int id 0):Person(name)//匿名对象 调用基类的构造函数初始化基类的成员, _id(id){}//拷贝构造Student(const Student s):Person(s), _id(s._id){}//赋值Student operator (const Student s){if (this ! s){Person::operator(s);//?_id s._id;}return *this;}~Student(){//显示调用父类析构无法保证先子后父// Person::~Person();//在子类析构函数完成,就调用父类析构,这样就保证了先子后父delete _ptr;}
private:int _id;int* _ptr new int;
};
int main()
{Student s1;Student s2(s1);Student s3(李四, 1);s1 s3;return 0;
}派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数则必须在派生类构造函数的初始化列表阶段显示调用。 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。 派生类的operator必须要调用基类的operator完成基类的复制。 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。 派生类对象初始化先调用基类构造再调派生类构造。 派生类对象析构清理先调用派生类析构再调基类的析构。 因为后续一些场景析构函数需要构成重写重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理处理成destrutor()所以父类析构函数不加virtual的情况下子类析构函数和父类析构函数构成隐藏关系。
注意 1、派生类和基类的赋值运算符重载函数函数名相同但是在不同作用域构成隐藏所以在派生类当中调用基类的赋值运算符重载函数时需要使用作用域限定符进行指定调用。 2、由于多态的某些原因任何类的析构函数名都会被统一处理为destructor();。因此派生类和基类的析构函数也会因为函数名相同构成隐藏若是我们需要在某处调用基类的析构函数那么就要使用作用域限定符进行指定调用。 3、在派生类的拷贝构造函数和operator当中调用基类的拷贝构造函数和operator的传参方式是一个切片行为都是将派生类对象直接赋值给基类的引用。
继承与友元
友元关系不能继承 即基类的友元可以访问基类的私有和保护成员但是不能访问派生类的私有和保护成员。
#include iostream
#include string
using namespace std;
class Student;
class Person
{
public://声明Display是Person的友元friend void Display(const Person p, const Student s);
protected:string _name; //姓名
};
class Student : public Person
{
protected:int _id; //学号
};
void Display(const Person p, const Student s)
{cout p._name endl; //可以访问cout s._id endl; //err
}
int main()
{Person p;Student s;Display(p, s);return 0;
}
如果Display函数需要访问派生类Student的私有和保护成员在派生类Student当中进行友元声明。
//有元关系不能继承
class Student;
class Person
{
public: friend void Display(const Person p, const Student s);
protected:string _name;
};class Student :public Person
{friend void Display(const Person p, const Student s);
protected :int _id;
};void Display(const Person p, const Student s)
{cout p._name endl;cout s._id endl;}int main()
{Person p;Student s;Display(p, s);return 0;
}静态成员
基类定义了static静态成员则整个继承体系里面只有一个这样的成员。无论派生出多少个子类都只有一个static成员实例
//基类
class Person
{
public:Person(){_count;}
protected :string _name;
public:static int _count;
};int Person::_count 0;
//派生类
class Student : public Person
{
protected :string _seminarCourse; //研究科目
};int main()
{Person p;Student s1;Student s2;cout Person::_count endl;return 0;
}菱形继承及菱形虚拟继承
继承的方式
单继承一个子类只有一个直接父类时称这个继承关系为单继承。 多继承一个子类有两个或两个以上直接父类时称这个继承关系为多继承。
菱形继承菱形继承是多继承的一种特殊情况。
菱形继承有数据冗余和二义性的问题。
//基类
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; //主修课程
};int main()
{Assistant a;//a._name peter;//errreturn 0;
}Assistant对象是多继承的Student和Teacher而Student和Teacher当中都继承了Person因此Student和Teacher当中都有_name成员直接访问Assistant的_name成员编译器不知道访问哪一个会报错
解决方案
//显示指定访问哪个父类的成员
a.Student::_name 张三;
a.Teacher::_name 李四;上述解决方案可以解决二义性问题但是不能解决数据冗余在Assistant的对象在Person成员始终会存在两份。
菱形虚拟继承
为了解决菱形继承的二义性和数据冗余问题出现了虚拟继承。 在Student和Teacher继承Person是使用虚拟继承即可解决问题。
#include iostream
#include string
using namespace std;
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; //主修课程
};
int main()
{Assistant a;a._name peter;cout a.Student::_name endl;cout a.Teacher::_name endl;//解决了数据冗余cout a.Student::_name endl;cout a.Teacher::_name endl;return 0;
}
此时就可以直接访问Assistant对象的_name成员了解决了二义性问题
菱形虚拟继承原理
class A
{
public:int _a;
};class B :public A
{
public : int _b;
};
class C :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;return 0;
}D类对象当中各个成员在内存当中的分布情况如下 菱形继承的数据冗余和二义性本质上是D类对象当中含有两个_a成员。
如果使用菱形虚拟继承时菱形继承当中D类对象的各个成员在内存当中的分布情况。
#include iostream
using namespace std;
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;return 0;
} 其中D类对象当中的_a成员被放到了最后而在原来存放两个_a成员的位置变成了两个指针这两个指针叫虚基表指针它们分别指向一个虚基表。 虚基表中包含两个数据第一个数据是为多态的虚表预留的存偏移量的位置这里我们不必关心第二个数据就是当前类对象位置距离公共虚基类的偏移量。
也就是说这两个指针经过一系列的计算最终都可以找到成员_a
若是将D类对象赋值给B类对象在这个切片过程中就需要通过虚基表中的第二个数据找到公共虚基类A的成员得到切片后该B类对象在内存中仍然保持这种分布情况。
D d;
B b d; //切片行为
