文章目录
- C++继承
- 基类 & 派生类
- 访问控制和继承
- 继承类型
- 多继承
- 虚继承
- 为什么需要虚继承
- 虚继承概念
- 继承
- 访问属性
- 构造函数的调用顺序
- 砖石继承
- 同名隐藏与赋值兼容规则
- 5.1、同名隐藏
- 5.2、赋值兼容规则
C++继承
面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类,这使得创建和维护一个应用程序变得更容易。也达到了重用代码功能和提高执行时间的效果。
当创建一个类时,不需要重新编写新的数据成员和成员函数,只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类,新建的类称为派生类。
继承代表了is a 关系。例如,哺乳动物是动物,狗是哺乳动物,因此,狗是动物,等。
基类 & 派生类
一个类可以派生自多个类,这意味着,它可以从多个基类继承数据和函数。定义一个派生类,我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名。
形式:
class derived-class: access-specifier base-class
其中,访问修饰符 access-specifier 是 public、protected 或 private 其中的一个,base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier,则默认为 private。
访问控制和继承
派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问,则应在基类中声明为 private。
根据访问权限总结出不同的访问类型,如下所示:
类型 | public | protected | private |
---|---|---|---|
同一个类 | 可以 | 可以 | 可以 |
派生类 | 可以 | 可以 | 不可以 |
其他类 | 可以 | 不可以 | 不可以 |
一个派生类继承了所有的基类方法,但下列情况除外:
- 基类的构造函数、析构函数和拷贝构造函数。
- 基类的重载运算符。
- 基类的友元函数。
继承类型
当一个类派生自基类,该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。
一般不使用 protected 或 private 继承,通常使用 public 继承。当使用不同类型的继承时,遵循以下几个规则:
- 公有继承(public):当一个类派生自公有基类时,基类的公有成员也是派生类的公有成员,基类的保护成员也是派生类的保护成员,基类的私有成员不能直接被派生类访问,但是可以通过调用基类的公有和保护成员来访问。
- 保护继承(protected): 当一个类派生自保护基类时,基类的公有和保护成员将成为派生类的保护成员。
- 私有继承(private):当一个类派生自私有基类时,基类的公有和保护成员将成为派生类的私有成员。
多继承
多继承即一个子类可以有多个父类,它继承了多个父类的特性。
C++ 类可以从多个类继承成员,语法如下:
class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};
其中,访问修饰符继承方式是 public、protected 或 private 其中的一个,用来修饰每个基类,各个基类之间用逗号分隔。
例子:
#include <iostream>using namespace std;// 基类 Shape
class Shape
{public:void setWidth(int w){width = w;}void setHeight(int h){height = h;}protected:int width;int height;
};// 基类 PaintCost
class PaintCost
{public:int getCost(int area){return area * 70;}
};// 派生类
class Rectangle: public Shape, public PaintCost
{public:int getArea(){ return (width * height); }
};int main(void)
{Rectangle Rect;int area;Rect.setWidth(5);Rect.setHeight(7);area = Rect.getArea();// 输出对象的面积cout << "Total area: " << Rect.getArea() << endl;// 输出总花费cout << "Total paint cost: $" << Rect.getCost(area) << endl;return 0;
}
虚继承
为什么需要虚继承
菱形继承是多重继承中跑不掉的,Java拿掉了多重继承,辅之以接口。C++中虽然没有明确说明接口这种东西,但是只有纯虚函数的类可以看作Java中的接口。在多重继承中建议使用“接口”,来避免多重继承中可能出现的各种问题。
虚继承概念
虚继承是一种机制,类通过虚继承指出它希望共享虚基类的状态。对给定的虚基类,无论该类在派生层次中作为虚基类出现多少次,只继承一个共享的基类子对象,共享基类子对象称为虚基类。虚基类用virtual声明继承关系就行。
#include <iostream>using namespace std;
//基类class D
{
public:D(){cout<<"D()"<<endl;}~D(){cout<<"~D()"<<endl;}
protected:int d;
};class B:virtual public D
{
public:B(){cout<<"B()"<<endl;}~B(){cout<<"~B()"<<endl;}
protected:int b;
};class A:virtual public D
{
public:A(){cout<<"A()"<<endl;}~A(){cout<<"~A()"<<endl;}
protected:int a;
};class C:public B, public A
{
public:C(){cout<<"C()"<<endl;}~C(){cout<<"~C()"<<endl;}
protected:int c;
};
int main()
{cout << "Hello World!" << endl;C c; //D, B, A ,Ccout<<sizeof(c)<<endl;return 0;
}
继承
这个机制是面向对象使代码复用的重要手段,在原有类的基础上进行扩展,增加功能;
继承的出现,应该主要是为了多态性;继承实质是是为了多态做准备。
访问属性
-
有public、protected、private继承,不写的话,默认私有继承;
class d : public B1,B2,B3,在这块,B1是公有继承,B2和B3是默认的,私有继承; -
class Base{};sizeof(Base); 空类,计算结果 1 字节;起标识作用
-
不管什么继承,子类均不会继承父类的构造方法和析构方法,其余的拷贝一份(包括私有,公有,保护)放到子类,只不过更改相应的修饰符权限。
-
不论什么继承,子类都不能直接访问父类的私有数据。
-
从对象和子类内看访问属性:
- 对象角度:永远只能访问公有方法;
- 子类内角度:子类永不可能直接访问父类的私有-------->安全性;
- 子类在公有继承(public)中,父类的(除去私有的)都可以访问;其继承下来的修饰符权限不用改;
- 子类在保护继承(protected)中,除去父类的私有,都可以访问;
- 子类在私有继承(private)中,;继承下来的属性都变为私有,原因:成员函数可以访问自己的私有数据;
-
protected----->只在继承中体现,其它的地方用不到这个;
- protected/private————>不同之处:影响下一层此的继承;private会阻断继承;
构造函数的调用顺序
- 当在继承时创建一个对象,其内部隐藏了先调用其父类的构造函数,先创建了父类的对象,其后创建子类对象;析构函数的调用与此相反;
-
按继承顺序,成员对象创建顺序,调用父类的构造函数,创建父类对象,最后创建自己对象;与参数列表的顺序无关;
-
看看有没有虚继承(virtual public B1);有的话,先调用虚继承的构造函数,在调用普通父类的构造函数,最后调用自己的,一切按顺序来;
砖石继承
继承下来时有2个n,在调用时候会产生二义性;其采用虚继承可以解决:
#include<iostream>
using namespace std;class Base{
public:int n;
};class D1 : virtual public Base{//加上virtual,表示虚继承
public: //public virtual Base和上面等同int x;
};class D2 : virtual public Base{ //加上virtual,表示虚继承
public:int y;
};class S : public D1, public D2{ //此时就只有一个n了;
public:int z;
};int main(){S c;c.n = 10;cout<<&c.D1::n<<endl; //因为同一个n,所以地址相同;cout<<&c.D2::n<<endl;return 0;
}
虚继承可以解决这类问题,就只有一个n被继承下来,就可以正确访问n了;
同名隐藏与赋值兼容规则
5.1、同名隐藏
#include<iostream>
using namespace std;class Base
{
public:void fun() //父类的无参fun()方法{cout<<"This is Base fun()"<<endl;}void fun(int a) //父类的一个参数的fun()方法{cout<<"This is Base fun(int)"<<endl;}
};class D : public Base
{
public:void fun() //子类的fun()方法{cout<<"This is D fun()"<<endl;}
};int main()
{D d;d.fun(); //肯定调用子类的fun()方法// d.fun(1); 此时因为函数名相同,隐藏了父类所有的该方法,子类有没有参数,所以报错d.Base::fun(1);//此时调用了父类的fun带参数的方法,刚才只是隐藏了,并没有覆盖!return 0;
}
子类在继承父类时,父类中与子类中函数名字相同的所有均被隐藏,(父类中同名的函数不能是虚函数)—>同名隐藏
5.2、赋值兼容规则
class Base{};void Cloud(Base *pb){pb->fun(); //没写虚函数,将访问父类的此方法;pb->show();
}int main(){Base b;D d;Cloud(&d);b = d; //(1)、子类对象可以直接给父类对象赋值Base *pb = &d; //(2)、子类对象的地址可以赋值给父类对象的指针Base &rb = d; //(3)、子类对象可以让父类对象所引用return 0;
}
以上就是赋值兼容三规则;在多态中将会体现出用处。