C++ Primer 学习笔记_31_面向对象编程(2)--继承（二）：继承与构造函数、派生类到基类的转换 、基类到派生类的转换

构造函数

拷贝构造函数

析构函数
=运算符

    基类的构造函数不被继承，派生类中需要声明自己的构造函数。
    声明构造函数时，只需要对本类中新增成员进行初始化，对继承来的基类成员的初始化调用基类构造函数完成（如果没有给出则默认调用默认构造函数）。
    派生类的构造函数需要给基类的构造函数传递参数

#include <iostream>
using namespace std;

class ObjectB
{
public:
    ObjectB(int objb) : objb_(objb)
    {
        cout << "ObjectB ..." << endl;
    }
    ~ObjectB()
    {
        cout << "~ObjectB ..." << endl;
    }
    int objb_;
};

class ObjectD
{
public:
    ObjectD(int objd) : objd_(objd)
    {
        cout << "ObjectD ..." << endl;
    }
    ~ObjectD()
    {
        cout << "~ObjectD ..." << endl;
    }
    int objd_;
};

class Base
{
public:
    Base(int b) : b_(b), objb_(111)
    {
        cout << "Base ..." << endl;
    }
    Base(const Base &other) : objb_(other.objb_), b_(other.b_)
    {

    }
    ~Base()
    {
        cout << "~Base ..." << endl;
    }
    int b_;
    ObjectB objb_;
};

class Derived : public Base
{
public:
    Derived(int b, int d) : d_(d), Base(b), objd_(222)
    {
        cout << "Derived ..." << endl;
    }
    Derived(const Derived &other) : d_(other.d_), objd_(other.objd_), Base(other)
    {

    }
    ~Derived()
    {
        cout << "~Derived ..." << endl;
    }
    int d_;
    ObjectD objd_;
};

int main(void)
{
    Derived d(100, 200);
    cout << d.b_ << " " << d.d_ << endl;

    Base b1(100);
    Base b2(b1);
    cout << b2.b_ << endl;

    Derived d2(d);
    return 0;
}

解释：从输出可以看出：

派生类对象的构造次序：

    先调用基类对象成员的构造函数，接着是基类的构造函数，然后是派生类的对象成员的构造函数，最后是派生类自身的构造函数。

    也可以这样来看：构造函数执行的顺序是先执行初始化列表，然后是函数体。初始化列表参 数多个且其中有调用基类构造函数时，先执行基类构造函数（从最远的开始，如果多重继承则按继承的顺序）；其他对象成员若不止一个，则按定义的顺序构造，与 初始化列表顺序无关。

    析构的顺序与构造的顺序相反。

友元关系不能被继承

静态成员无所谓继承

【例子】

#include <iostream>
using namespace std;

class Base
{
public:
    static int b_;
};

int Base::b_ = 100;
class Derived : public Base
{

};

int main(void)
{
    Base b;
    Derived d;
    cout << Base::b_ << endl;
    cout << b.b_ << endl;

    cout << Derived::b_ << endl;
    cout << d.b_ << endl;
    return 0;
}

运行结果：

100
100
100
100

解释：都能访问，输出100，但推荐使用类::xx 访问，如b.b_ 访问存在歧义，实际上static成员不属于任一对象。

C++用户自定义的转换规则是：

1、在public继承方式（private、protected继承时，不能隐式转换）下，派生类的对象/对象指针/对象引用可以赋值给基类的对象/对象指针/对象引用（发生隐式转换）。基类的对象/对象指针/对象引用不能赋值给派生类的对象/对象指针/对象引用。因为派生类包含了基类的所有信息，而基类缺乏派生类中的信息。

【例子】

class A{};
class B: public A{};
A a;
B b;

则：

a = b; //合法，派生类向基类隐式转换
b = a; //错误，基类向派生类转换，语句1
A* pa = &b;  //合法，隐式转换
B* pb = &a;  //错误，语句2
A& qa = b;  //合法，隐式转换
B& qb = a;  //错误，语句3

语句3改为：

B& qb = (B&)a;  //合法

3、一个指向基类的指针可以用来指向该基类公有派生类的任何对象，这是C++实现程序运行时多态性的关键。

注意：上述隐式转换将会在后文的static_cast处用到。

【例子】

#include <iostream>
#include <string>
using namespace std;

class Employee
{
public:
    Employee(const string &name, const int age, const int deptno) : name_(name),
        age_(age), deptno_(deptno)
    {

    }
private:
    string name_;
    int age_;
    int deptno_;
};

class Manager : public Employee
{
public:
    Manager(const string &name, const int age, const int deptno, int level)
        : Employee(name, age, deptno), level_(level)
    {

    }
private:
    int level_;
};

class Manager2 : private Employee
{
public:
    Manager2(const string &name, const int age, const int deptno, int level)
        : Employee(name, age, deptno), level_(level)
    {

    }
private:
    int level_;
};

int main(void)
{
    Employee e1("zhangsan", 25, 20);
    Manager m1("lisi", 38, 20, 10);
    Manager2 m2("wangwu", 40, 15, 8);
    Employee *pe;
    Manager *pm;
    Manager2 *pm2;

    pe = &e1;
    pm = &m1;
    pm2 = &m2;

    pe = &m1;   // 派生类对象指针可以转化为基类对象指针。将派生类对象看成基类对象 
    //pm = &e1; // 基类对象指针无法转化为派生类对象指针。无法将基类对象看成是派生类对象
    e1 = m1;    // 派生类对象可以转化为基类对象。将派生类对象看成基类对象   
    // 会产生对象切割（派生类特有成员消失）。object slicing
    //pe = pm2; //私有或保护继承的时候，派生类对象指针不可以自动转化为基类对象指针
    pe = reinterpret_cast<Employee *>(pm2);

    //e1 = m2;  // 私有或保护继承的时候，派生类对象无法转化为基类对象。
    //e1 = reinterpret_cast<Employee>(m2); // 私有或保护继承的时候，派生类对象无法强制转化为基类对象。

    pm = static_cast<Manager *>(pe);    // 基类指针可以强制转化为派生类指针，但是不安全
    //m1 = reinterpret_cast<Manager>e1; // 基类对象无法强制转化为派生类对象
    return 0;
}

参考：

C++ primer 第四版

C++ primer 第五版

版权声明：本文为博主原创文章，未经博主允许不得转载。