继承性:" 继承 "是面向对象软件技术当中的一个概念,是类间的一种基本关系,是基于层次关系的不同类共享数据和操作的一种机制。父类定义了其所有子类的公共属性和操作,在子类中除了定义自己特有的属性和操作外,还可以对父类(或祖先类)中的操作重新定义其实现方法,即重载.
继承可以使得子类具有父类的各种属性和方法,而不需要再次编写相同的代码。在令子类继承父类的同时,可以重新定义某些属性,并重写某些方法,即覆盖父类的原有属性和方法,使其获得与父类不同的功能. 继承是指一个对象直接使用另一对象的属性和方法.事实上,我们现实中遇到的很多实体都有继承的含义.例如,若把汽车看成一个实体,它可以分成多个子实体,如:卡车、公共汽车等.这些子实体都具有汽车的特性,因此,汽车是它们的"父亲",而这些子实体则是汽车的"孩子".
继承有三种继承方式:
(1)公有继承:基类成员保持自己的访问级别:基类的public成员在派生类中还是public,基类的protected成员在派生类中还是protected。
在基类中的访问权限 | 在派生类中的访问权限 |
private | 不可直接访问 |
public | public |
protected | protected |
对于公有继承方式,基类成员对其对象的可见性与一般类及其对象的可见性相同,公有成员可见,其他成员不可见.这里保护成员与私有成员相同.基类成员对派生类的可见性对派生类来说,基类的公有成员和保护成员可见,基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态;基类的私有成员不可见,基类的私有成员仍然是私有的,派生类不可访问基类中的私有成员.基类成员对派生类对象的可见性对派生类对象来说,基类的公有成员是可见的,其他成员是不可见. 所以,在公有继承时,派生类的对象可以访问基类中的公有成员,派生类的成员函数可以访问基类中的公有成员和保护成员.
(2)受保护继承:基类的public和protected成员在派生类中成为protected成员。
在基类中的访问权限 | 在派生类中的访问权限 |
private | 不可直接访问 |
public | protected |
protected | protected |
对于保护继承方式,这种继承方式与私有继承方式的情况相同,两者的区别仅在于对派生类的成员而言,基类成员对其对象的可见性与一般类及其对象的可见性相同,公有成员可见,其他成员不可见. 基类成员对派生类的可见性对派生类来说,基类的公有成员和保护成员是可见的,基类的公有成员和保护成员都作为派生类的保护成员,并且不能被这个派生类的子类所访问;基类的私有成员是不可见的,派生类不可访问基类中的私有成员.基类成员对派生类对象的可见性对派生类对象来说,基类的所有成员都是不可见的.所以,在保护继承时,基类的成员也只能由直接派生类访问,而无法再往下继承.
(3)私有继承:基类的所有成员在派生类中成为private成员。
在基类中的访问权限 | 在派生类中的访问权限 |
private | 不可直接访问 |
public | private |
protected | private |
对于私有继承方式,基类成员对其对象的可见性与一般类及其对象的可见性相同,公有成员可见,其他成员不可见.基类成员对派生类的可见性对派生类来说,基类的公有成员和保护成员是可见的,基类的公有成员和保护成员都作为派生类的私有成员,并且不能被这个派生类的子类所访问;基类的私有成员是不可见的,派生类不可访问基类中的私有成员.基类成员对派生类对象的可见性对派生类对象来说,基类的所有成员都是不可见的. 所以,在私有继承时,基类的成员只能由直接派生类访问,而无法再往下继承.
对于C++三大特性之一的继承机制,要想理解好它,需要多敲一些小程序练习观察总结,下面是一个多继承的例子,涉及到的知识点较多,可以比较学习。
#include <iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"int A::A()"<<endl;
}
A(A &a)
{
cout<<"int A::A(A &a)"<<endl;
}
A& operator=(A& a)
{
cout<<"int A::operator=(A &a)"<<endl;
return a;
}
virtual ~A()
{
cout<<"int A::~A()"<<endl;
}
};
class M :public A
{
public:
M()
{
cout<<"int M::M()"<<endl;
}
M(M &a)
{
cout<<"int M::M(M &a)"<<endl;
}
M& operator=(M& m)
{
cout<<"int M::operator=(M &a)"<<endl;
return m;
}
virtual ~M()
{
cout<<"int M::~M()"<<endl;
}
};
class B:virtual public M
{
public:
B()
{
cout<<"int B::B()"<<endl;
}
B(B &a)
{
cout<<"int B::B(B &a)"<<endl;
}
B& operator=(B& b)
{
cout<<"int B::operator=(B &a)"<<endl;
return b;
}
virtual ~B()
{
cout<<"int B::~B()"<<endl;
}
};
class N :public A
{
public:
N()
{
cout<<"int N::N()"<<endl;
}
N(N &a)
{
cout<<"int N::N(N &a)"<<endl;
}
N& operator=(N& n)
{
cout<<"int N::operator=(N &a)"<<endl;
return n;
}
virtual ~N()
{
cout<<"int N::~N()"<<endl;
}
};
class C:virtual public N
{
public:
C()
{
cout<<"int C::C()"<<endl;
}
C(C &a)
{
cout<<"int C::C(C &a)"<<endl;
}
C& operator=(C& c)
{
cout<<"int C::operator=(C &a)"<<endl;
return c;
}
virtual ~C()
{
cout<<"int C::~C()"<<endl;
}
};
class E:virtual public M
{
public:
E()
{
cout<<"int E::E()"<<endl;
}
E(E &a)
{
cout<<"int E::E(E &a)"<<endl;
}
E& operator=(E& e)
{
cout<<"int E::operator=(E &a)"<<endl;
return e;
}
virtual ~E()
{
cout<<"int E::~E()"<<endl;
}
};
class D:public B, public C, public E
{
public:
D()
{
cout<<"int D::D()"<<endl;
}
D(D &a)
{
cout<<"int D::D(D &a)"<<endl;
}
D& operator=(D& d)
{
cout<<"int D::operator=(D &a)"<<endl;
return d;
}
virtual ~D()
{
cout<<"int D::~D()"<<endl;
}
};
int main(int argc, char *argv[])
{
cout<<"-------构造函数-------"<<endl;
D d;
cout<<"-------复制构造函数-------"<<endl;
D d1(d);
cout<<"-------赋值操作符-------"<<endl;
d = d1;
cout<<"-------析构函数-------"<<endl;
return 0;
}