继承(二)

2019-09-30 06:38:51来源:博客园 阅读 ()

继承(二)

目录

  • 1. 父子间的同名冲突
    • 同名变量冲突
    • 同名函数冲突
  • 2. 同名冲突引发的问题
    • 父子间的赋值兼容
    • 函数重写
    • 当函数重写遇上赋值兼容
  • 3. 继承中的强制类型转换

1. 父子间的同名冲突

同名变量冲突

  • 子类可以定义父类中的同名成员变量
  • 父类中的同名成员变量被隐藏,但仍然存在于子类中
  • 父类中的同名成员变量需要通过作用域分辨符(::)访问
Child c;
c.mi = 100;           //访问子类中的mi
c.Parent::mi = 1000;  //访问父类中的mi
#include <iostream>
#include <string>

using namespace std;

namespace A
{
int g_i = 0;
}

namespace B
{
int g_i = 1;
}

class Parent
{
public:
    int mi;

    Parent()
    {
        cout << "Parent() : " << "&mi = " << &mi << endl;
    }
};

class Child : public Parent
{
public:
    int mi;

    Child()
    {
        cout << "Child() : " << "&mi = " << &mi << endl;
    }
};

int main()
{
    Child c;

    c.mi = 100;
    c.Parent::mi = 1000;

    cout << endl;
    cout << "&c.mi = " << &c.mi << endl;
    cout << "c.mi = " << c.mi << endl;
    cout << endl;

    cout << "&c.Parent::mi = " << &c.Parent::mi << endl;
    cout << "c.Parent::mi = " << c.Parent::mi << endl;

    return 0;
}

同名函数冲突

  • 子类中的成员函数将隐藏父类的同名成员函数(只需要同名即可,对参数列表和返回值类型无要求
  • 使用作用域分辨符访问父类中的同名成员函数
  • 子类可以定义与父类完全相同的成员函数(包括函数名,参数列表、返回值类型)
  • 子类无法重载父类中的成员函数
#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;

    void add(int v)
    {
        mi += v;
    }

    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mi;

    void add(int v)
    {
        mi += v;
    }

    void add(int a, int b)
    {
        mi += (a + b);
    }

    void add(int x, int y, int z)
    {
        mi += (x + y + z);
    }
};

int main()
{
    Child c;

    c.mi = 100;
    c.Parent::mi = 1000;

    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent::mi = " << c.Parent::mi << endl;

    c.add(1);
    c.add(2, 3);
    c.add(4, 5, 6);

    c.Parent::add(1);
    c.Parent::add(2, 3);

    cout << "c.mi = " << c.mi << endl;
    cout << "c.Parent::mi = " << c.Parent::mi << endl;

    return 0;
}

2. 同名冲突引发的问题

父子间的赋值兼容

父子间的赋值兼容,指的是子类对象可以当作父类对象使用,具体表现在两个方面

  • 子类对象可以直接初始化父类对象,或者给父类对象赋值
  • 父类指针(引用)可以直接指向(引用)子类对象
  • 实际上仅仅指向(引用)了子类对象中的父类部分
  • 通过父类指针(引用),只能访问父类中的成员变量和成员函数
  • 子类对象本身不受影响,依然可以访问自身的成员
#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    int mi;

    Parent(int i = 0)
    {
        mi = i;
    }

    void add(int i)
    {
        mi += i;
    }

    void add(int a, int b)
    {
        mi += (a + b);
    }
};

class Child : public Parent
{
public:
    int mv;

    Child(int v = 0)
    {
        mv = v;
    }

    void add(int x, int y, int z)
    {
        mv += (x + y + z);
    }
};

int main()
{
    Parent p;
    Child c;

    /*子类对象初始化或赋值给父类对象,仅仅用子类对象中的父类部分进行相应操作*/
    p = c;
    Parent p1(c);

    /*父类指针或引用指向子类对象,指向的仅仅是子类中的父类部分*/
    Parent &rp = c;
    Parent *pp = &c;

    rp.mi = 100;
    rp.add(5);
    rp.add(10, 10);

    cout << "p.mi = " << p.mi << endl;
    cout << "c.mv = " << c.mv << endl;
    cout << "rp.mi = " << rp.mi << endl;
    cout << "pp->mi = " << pp->mi << endl;
    cout << endl;

    /*编译不过,只能访问父类中的成员*/
    // pp->mv = 1000;
    // pp->add(1, 10, 100);

    /*父类指针或引用指向子类对象,对子类对象本身没有影响*/
    c.mv = 1000;
    c.add(1, 1, 1);

    cout << "p.mi = " << p.mi << endl;
    cout << "c.mv = " << c.mv << endl;
    cout << "rp.mi = " << rp.mi << endl;
    cout << "pp->mi = " << pp->mi << endl;

    return 0;
}

函数重写

  • 子类可以重定义父类中已经存在的成员函数
  • 这种重定义发生在继承中,叫做函数重写
  • 函数重写是同名覆盖的一种特殊情况
class Parent
{
public:
    void print()
    {
        cout << "I'm Parent." << endl;
    }
};

class Child : public Parent
{
public:
    void print()
    {
        cout << "I'm Child." << endl;
    }
};

当函数重写遇上赋值兼容

当函数重写遇上赋值兼容时会发生什么,下面的示例代码展示了这个问题。

#include <iostream>
#include <string>

using namespace std;

class Parent
{
public:
    void print()
    {
        cout << "I'm Parent" << endl;
    }
};

class Child : public Parent
{
public:
    void print()
    {
        cout << "I'm Child" << endl;
    }
};

void how_to_print(Parent *p)
{
    p->print();
}

int main()
{
    Parent p;
    Child c;

    how_to_print(&p);  // Expected: I'm Parent
    how_to_print(&c);  // Expected: I'm Child

    return 0;
}

第34-35行注释部分展示了我们期望的结果,但实际运行结果和期望不符,原因在于

  • 编译期间,编译器只能根据指针(引用)的类型判断所指向(引用)的对象
  • 根据赋值兼容,编译器认为父类指针(引用)指向(引用)的是父类对象
  • 因此,编译结果只可能是调用父类中定义的同名函数

编译器的处理方法是合理的,但不是我们期望的,这就是同名冲突引发的问题,要想解决这个问题,需要用到多态的知识。

3. 继承中的强制类型转换

我们之前讲过了C++的四种强制类型转换,那么在继承中如何正确地使用强制类型转换呢?

  • dynamic_cast是与继承相关的类型转换关键字
  • dynamic_cast要求相关的类中必须有虚函数
  • dynamic_cast用于有直接或者间接继承关系的类指针(引用)之间
  • 指针:转换成功,得到目标类型的指针;转换失败,得到一个空指针
  • 引用:转换成功,得到目标类型的引用;转换失败,得到一个异常操作信息
  • 编译器会检查dynamic_cast的使用是否正确
  • 类型转换的结果只可能在运行阶段才能得到
/*
** 继承中的dynamic_cast关键字
*/

#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    Base()
    {
        cout << "Base::Base()" << endl;
    }

    /*
     * dynamic_cast要求类中必须有虚函数,因此将父类的析构函数定义为虚函数
    */
    virtual ~Base()
    {
        cout << "Base::~Base()" << endl;
    }
};

class Derived : public Base
{

};

int main()
{
    Base *p0 = new Derived;
    Base *p1 = new Base;
    Base &p2 = *p1;

    Derived *pd0 = dynamic_cast<Derived *>(p0); //dynamic_cast转换指针成功,得到目标类型指针
    Derived *pd1 = dynamic_cast<Derived *>(p1); //不能用子类指针指向一个父类对象,dynamic_cast转换指针失败,得到的pd1为NULL

    cout << "pd0 = " << pd0 << endl;
    cout << "pd1 = " << pd1 << endl;

    Derived &pd2 = dynamic_cast<Derived &>(p2); //dynamic_cast转换引用失败,运行时抛出异常

    delete p0;
    delete p1;

    return 0;
}


原文链接:https://www.cnblogs.com/songhe364826110/p/11601383.html
如有疑问请与原作者联系

标签:Q定义load代码对象注释

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:C++类拷贝控制 深拷贝 浅拷贝

下一篇:算法分析之猴子吃桃