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

转:http://blog.csdn.net/jnu_simba/article/details/9312659

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

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

析构函数
=运算符


二、继承与构造函数

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


 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#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( 100200);
    cout << d.b_ <<  " " << d.d_ << endl;

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

    Derived d2(d);
     return  0;
}


从输出可以看出:

派生类对象的构造次序:

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

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

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


三、友元关系、静态成员与继承

友元关系不能被继承

静态成员无所谓继承

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#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

不能把派生类对象强制转换为基类对象


 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#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"2520);
    Manager m1( "lisi"382010);
    Manager2 m2( "wangwu"40158);
    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
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值