从零开始学C++之继承(二):继承与构造函数、派生类到基类的转换

一、不能自动继承的成员函数

构造函数(包括拷贝构造函数)

析构函数 =运算符

二、继承与构造函数

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

#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,但推荐使用类::xx 访问,如b.b_ 访问存在歧义,实际上static成员不属于任一对象。

四、派生类到基类的转换

当派生类以public方式继承基类时,编译器可自动执行的转换(向上转型 upcasting 安全转换)

派生类对象指针自动转化为基类对象指针 派生类对象引用自动转化为基类对象引用 派生类对象自动转换为基类对象(特有的成员消失)

当派生类以private/protected方式继承基类时

派生类对象指针(引用)转化为基类对象指针(引用)需用强制类型转化。但不能用static_cast,要用reinterpret_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;
}

五、基类到派生类的转换

基类对象指针(引用)可用强制类型转换为派生类对象指针(引用), 而基类对象无法执行这类转换. 向下转型不安全,没有自动转换的机制

// 从语法上来演示基类对象可以转化为派生类对象,但是没有意义

1、转换构造函数: Manager(const Employee& other) : Employee(other), level_(-1) { }

2、类型转换运算符:

Employee::operator Manager() {

return Manager(name_, age_, deptno_, -1);

}

参考:

C++ primer 第四版 Effective C++ 3rd C++编程规范

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏LinkedBear的个人空间

唠唠SE的面向对象-10——多态 原

3:当父类和子类具有相同的非静态方法(就是子类重写父类方法),多态下访问的是子类的成员方法。

653
来自专栏测试开发架构之路

C++之面向对象的三个基本特征

三大特性是:封装,继承,多态   所谓封装 就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏.封装是面...

2706
来自专栏用户2442861的专栏

轻松搞定面试中的“虚”

http://blog.csdn.net/silangquan/article/details/18322087

872
来自专栏塔奇克马敲代码

第 15 章 面向对象程序设计

2063
来自专栏http://www.cnblogs.com

面向对象编程-类

面向对象编程OOP (object-oriented programming)是最有效的软件编写方法之一,面向对象是利用“类”和“对象”来创建各种模拟来实现对真...

30713
来自专栏C/C++基础

C++不要在构造函数和析构函数中调用虚函数

虽然可以对虚函数进行实调用,但程序员编写虚函数的本意应该是实现动态联编。在构造函数中调用虚函数,函数的入口地址是在编译时静态确定的,并未实现虚调用。但是为什么在...

862
来自专栏有趣的Python

5-Java面向对象-继承(下)

前面我们学习了继承的概念和特点;继承的代码实现;方法重写;访问修饰符的分类及作用;super关键字的使用;继承的初始化顺序

853
来自专栏和蔼的张星的图像处理专栏

C++面向对象编程一些拾遗

虽然说是拾遗,但是这里有一大部分是我以前没有看过的,简书的markdown不支持生成目录,可能需要手动来一个了。

802
来自专栏java系列博客

MD5压缩算法

2066
来自专栏游戏杂谈

C++学习笔记 -- 虚析构函数与纯虚析构函数

一个类维护一个虚函数相关的表--vtable(__vfptr指向它),函数声明前面包含关键字“virtual”的函数,就会创建一个指向该函数的指针(函数指针)被...

694

扫码关注云+社区