c++第七天 继承与派生2

这一篇文章主要内容是

派生类构造函数与析构函数

在派生类中重写基类成员

以及多继承

第一部分：派生类构造函数与析构函数

        当创建一个派生类对象时，基类成员是如何初始化的？

1.当派生类对象创建的时候，基类成员的初始化顺序

（1）先初始化基类部分，再初始化派生类自己的成员

（2）也就是说，派生类对象在构造时，首先会调用基类的构造函数，把基类的成员变量初始化好，然后才会执行派生类自己的构造函数与成员初始化。

那么一般是什么样子的呢？

class Base {
public:Base() { cout << "Base构造" << endl; }~Base() { cout << "Base析构" << endl; }
};class Derived : public Base {
public:Derived() { cout << "Derived构造" << endl; }~Derived() { cout << "Derived析构" << endl; }
};int main() {Derived d;return 0;
}

  是这样的格式，首先进行的是初始化工作，然后再进行派生。

这里输出的结果是

Base构造
Derived构造
Derived析构
Base析构

第二个问题：当派生类对象销毁时，析构的顺序是什么样子的？

先析构派生类自己的成员，再析构基类部分。

也就是说，派生类对象销毁时，先执行派生类的析构函数，然后再自动调用基类的析构函数。

总结口诀：

构造顺序：先基类，后派生

析构顺序：先派生，后基类 

①在创建派生类对象时，首先会调用基类的构造函数，然后再调用派生类的构造函数。

#include<iostream>class Base{
public:Base(){std::cout << "Base constructor called" << std::endl;}
};class Derived : public Base{
public:Derived(){std::cout << "Derived constructor called" << std::endl;}
};int main()
{Derived d;return 0;
}

只要创建派生类对象，必然会调用基类构造函数

②当基类的构造函数需要参数时，派生类的构造函数需要显式地调用基类的构造函数并传递参数。

#include<iostream>
using namespace std;class Base{
public:Base(int value){std::cout << "Base constructor called with value" << value << std::endl;}
};class Derived : public Base{
public:Derived(int baseValue,int derivedValue) : Base(baseValue){std::cout << "Derived construtor called with value" << derivedValue << std::endl;}
};
int main()
{Derived d(10,20);return 0;
}

③派生类构造函数中初始化列表的作用和使用方法。初始化列表可以用于调用

a.基类的构造函数，b.对象成员的构造函数，c.派生类自身的成员变量。

#include <iostream>
using namespace std;class Base {
public:Base(int d):data(d) { cout << "Base" << endl; }int getData() {return data;}
protected:int data;
};class Derived : public Base {
private:Base b;         //对象成员int c;
public:Derived():Base(0),b(1) { cout << "Derived" << endl; }Derived(int x) :Base(x),b(2*x),c(3*x) {  }
};int main()
{Derived d(10);cout << d.getData() << endl;return 0;
}

④默认构造函数和自定义构造函数。如果基类有默认构造函数，派生类的构造函数可以不显式调用基类的构造函数，编译器会自动调用基类的默认构造函数。但如果基类没有默认构造函数，派生类的构造函数必须显式调用基类的构造函数。

⑤析构函数的调用顺序：在销毁派生类对象时，首先会调用派生类的析构函数，然后再调用基类的析构函数。（一句话：和构造的顺序相反）

#include <iostream>
using namespace std;class Base {
public:Base(int d):data(d) { cout << "Base" <<data<< endl; }int getData() {return data;}~Base() { cout << "Base析构" <<data<< endl; }
protected:int data;
};class Derived : public Base {
private:Base b;//对象成员int c;
public:Derived():Base(0),b(1) { cout << "Derived" << endl; }Derived(int x) :Base(x), b(2 * x) { c = 3 * x; }~Derived() { cout << "Derived析构" << endl; }
};int main()
{Derived d(10);cout << d.getData() << endl;return 0;
}

输出结果

1. 1. 1. 在派生类中重写基类成员

重写是指在派生类中定义一个与基类中同名、同参数列表、同返回类型的成员函数，以此来改变基类函数的行为。

重载是在同一类中，函数名相同但参数列表不同。

#include<iostream>
using namespace std;class Base{
public:void display(){std::cout << "This is the Base222 class." << std::endl;}
};class Derived : public Base{
public:void display(){cout << "This is the Base class" << endl;}};int main()
{Derived d;d.display();return 0;
}

重写的函数（派生类中）必须与基类函数的函数名、参数列表和返回类型完全相同。否则就会变成重载（要求参数不同）重写函数的访问权限可以不同，但通常建议保持一致。例如，基类函数是 public，派生类重写函数也用 public。

1. 多继承

单继承：一个派生类只能有一个直接基类；当需要组合多个不同类的特性时，单继承无法直接实现，需多继承。即多继承具有更强的代码重用的能力。

class 派生类 : 继承方式 基类1, 继承方式 基类2, ... {

    // 成员声明

};

多继承下的构造函数与析构函数的调用顺序

 

#include<iostream>
using namespace std;class Speakable{
public:Speakable() {cout << "Speakable构造" << endl;}void speak() {cout << "Speaking..." << endl;}
};class Moveable{
public:Moveable() {cout << "Moveable构造" << endl;}void move() {cout << "moving..." << endl;}
};class Robot : public Speakable,public Moveable{
public:Robot() : Moveable(),Speakable() {}
};int main()
{Robot r;r.speak();r.move();return 0;
}

多继承的二义性：

#include<iostream>
using namespace std;
class A {public:void f() { cout << "A"; }
};
class B {
public:void f() { cout << "B"; }
};class AB :public A, public B {public://void f() { cout << "AB"; }
};
int main()
{AB ab;ab.B::f();ab.A::f();return 0;
}

错误提示：对“f”的访问不明确

解决的办法：就是在成员函数的前面加上类名::，说明使用从哪个基类继承的成员函数。

ab.B::f();

ab.A::f();