目录
继承的好处
父类所有书信与方法的访问权限都被子类继承了,提高了代码的复用性。
子类可以添加独有的新特性,提高了代码的拓展性。
语法
class + 子类类名 : 继承权限 父类类名
{
//子类的类体
}继承权限
内存空间关系
同名属性隐藏
1.子类中有与父类同名属性或函数名是,父类中的属性与函数将自动隐藏在父类的类域之中
2.调用父类属性/方法：子类名 . 父类名 : : 属性/方法
注: 如果父类中没有默认构造时,需要在子类的初始化列表中指定对父类进行初始化.
析构时机
1.当派生类对象被构建时,编译器会自动调用父类的默认构造,然后再调用子类相应的实参构造
2.当派生类对象被析构时,编译器会先调用子类的析构,当子类被析构后,父类的析构也将会自动调用
简单继承演示：
定义一个父类：
#include <iostream>
using namespace std;
class Car
{
private:
int weight;
public:
Car (int w)
{
this->weight = w;
cout << "Car的构造" << endl;
cout << "Car的地址" << this << endl;
}
~Car()
{
cout << "Car的析构" << endl;
}
void run()
{
cout << "车子正在行驶中" << endl;
}
};定义两个子类：用public继承
class BMW : public Car
{
public:
BMW():Car(100) //可在子类给父类初始化
{
cout << "BMW的构造" << endl;
}
~BMW()
{
cout << "BMW的析构" << endl;
}
//子类独有方法
void happy_cry()
{
//错误,public继承不能访问父类私有成员,
//若想访问,需在父类定义外部接口
//cout << this->weight << endl;
cout << "幸福的泪水" << endl;
}
//与父类同名方法
void run()
{
cout << "高速行驶" << endl;
}
};
class BNZ : public Car
{
public:
BNZ():Car(100)
{
cout << "BNZ的构造" << endl;
}
~BNZ()
{
cout << "BNZ的析构" << endl;
}
};主函数：
int main()
{
BMW bmw;
bmw.happy_cry(); //子类方法
bmw.run(); //父类同名属性隐藏,结果是子类方法
bmw.Car::run(); //可使用::域名访问调用父类方法
cout << "bmw的地址" << &bmw << endl;
cout << "--------------" << endl;
BNZ bnz;
cout << "bnz的地址" << &bnz << endl;
cout << "---------------" << endl;
}运行结果：
BNZ类与BMW类地址相差一个4个字节，证明子类继承了父类的属性，并占用相应的空间。
父子指针类型转换
1.使用父类指针或引用，可以指向或引用子类的对象，是安全的，无需进行转型
2.子类指针强转成父类指针是安全的
2.当使用父类指针指向子类对象时，如果使用父类指针强转为子类类型时，要保证子类对象内存确定被开辟了才行，否则是不安全的。
代码演示：
父类和子类代码：
#include <iostream>
using namespace std;
class A
{
private:
int a;
public:
A():a(10)
{
cout << "A的构造" << endl;
}
~A()
{
cout << "A的析构" << endl;
}
int getA()
{
return this->a;
}
};
class B : public A
{
private:
int b;
public:
B():b(200)
{
cout << "B的构造" << endl;
}
~B()
{
cout << "B的析构" << endl;
}
int getB()
{
return this->b;
}
};主函数：
int main()
{
//父类转子类,要确保子类空间已开辟
A* a = new B;
cout << a->getA() << endl;
cout << ((B*)a)->getB() << endl;
cout << static_cast<B*>(a)->getB() << endl;
delete a;
cout << "-------------" << endl;
//子类转父类
B* b = new B;
cout << ((A*)b)->getA() << endl;
cout << static_cast<A*>(b)->getA() << endl;
delete b;
return 0;
}运行结果：
多继承
语法
class 子类 : 继承权限1 父类1, 继承权限2 父类2,继承权限3 父类3, ....
{
//多重继承类类体
};优势：提高的代码的复用性。
缺点: 代码冗余，重名问题。
重名问题:通过作用域：：的形式来访问具体某个父类中的属性或方法。
代码冗余：多继承时，继承多个抽象类（一般不写属性，只写抽象方法（纯虚函数）。）
多继承代码演示：
#include <iostream>
using namespace std;
class Phone
{
public:
int power;
public:
void mail()
{
cout << "通信功能" << endl;
}
void playGame() //两个父类有同名方法
{
cout << "手机游戏功能" << endl;
}
};
class Computer
{
public:
int power;
public:
void playGame() //两个父类有同名方法
{
cout << "电脑游戏功能" << endl;
}
};
class NotePad : public Phone, public Computer
{
public:
void getPower()
{
cout << this->Computer::power << endl;
}
void play()
{
//this->playGame(); //此写法错误，编译器识别到两个同名方法。
this->Computer::playGame(); //可通过域名访问
}
};
int main()
{
NotePad note;
note.play();
note.mail(); //不重名方法可直接调用
note.Phone::playGame(); //同名方法可用域名调用
cout << sizeof(note) << endl; //8, 两个父类的int属性大小
return 0;
}运行结果：
菱形继承
知识拓展：
虚继承：
1.当在类中使用virtual声明一个成员函数为虚函数时，在编译时，编译器会自动在基类中默默地安插一个虚函数表指针，同时的.rodata段为这类生成一张虚函数表，用来保存类中的虚函数的地址。
2.当继承关系发生时，父类中的虚基表指针就被子类给继承了下来，所以他的类对象空间就增大了一个指针的大小。（并非是虚基表被继承）
菱形继承关系图：
菱形继承代码演示：（非vritual版）
远端父类：
#include <iostream>
using namespace std;
class A
{
public:
int ma[9]; //这里用9个int，方便等会介绍内存图
A()
{
cout << "A的构造" << endl;
}
~A()
{
cout << "A的析构" << endl;
}
};中间父类:
class B : public A
{
public:
int mb = 200;
B()
{
cout << "B的构造" << endl;
}
~B()
{
cout << "B的析构" << endl;
}
};
class C : public A
{
public:
int mc = 300;
C()
{
cout << "C的构造" << endl;
}
~C()
{
cout << "C的析构" << endl;
}
};
子类及主函数：
class D : public B, public C
{
public:
int md = 400;
D()
{
cout << "D的构造" << endl;
}
~D()
{
cout << "D的析构" << endl;
}
};
int main()
{
D d;
cout << "sizeof(A)" << sizeof(A) << endl;
cout << "sizeof(B)" << sizeof(B) << endl;
cout << "sizeof(C)" << sizeof(C) << endl;
cout << "sizeof(D)" << sizeof(D) << endl;
cout << "---------------" << endl;
cout << "sizeof(d)" << sizeof(d) << endl;
return 0;
}
运行结果：
内存图：
可见，A类属性被拷贝了两次，若远端父类占用内存很大，则会浪费很多空间。
因此，在继承时，加上vritual关键字，则编译器会进行优化，A类属性只被引用一次，大大节省了空间，但会产生一个虚基表指针，64位机中占8字节，是可以接受的。
对菱形继承升级：（vritual版）
仅改变中间父类的继承方式即可：
class B :virtual public A
{
public:
int mb = 200;
B()
{
cout << "B的构造" << endl;
}
~B()
{
cout << "B的析构" << endl;
}
};
class C :virtual public A
{
public:
int mc = 300;
C()
{
cout << "C的构造" << endl;
}
~C()
{
cout << "C的析构" << endl;
}
};
运行结果：
内存图（64位机）：
B类或C类内存图：
D类内存图：
建议：
如果在公司开发中，如果可以使用包含关系和使用继承关系都可解决这个问题，优先选择包含关系。
如果有单继承关系与多继承关系，优先选择单继承关系。
如果必须使用多继承，请多继承多个抽象类，而非实体类。
如果无法避免的要做为棱形继承这种多继承中的特殊形式，请一定使虚继承。