c++基础学习12-c++的多态与继承

最新推荐文章于 2024-07-27 13:52:26 发布

你不爱欧文

最新推荐文章于 2024-07-27 13:52:26 发布

阅读量443

点赞数

分类专栏： c++ 文章标签：多态 c++基础继承

本文链接：https://blog.csdn.net/www594025270/article/details/39050873

版权

c++ 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1，函数重写

如果子类定义了与父类中原型相同的函数会发生什么？

1，在子类中定义与父类中原型相同的函数。

2，函数重写只发生在父类与子类之间。

#include <cstdlib>
#include <iostream>
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;
                }
};

父类中被重写的函数依然会继承给子类。

默认情况下子类中重写的函数将隐藏父类中的函数。

通过作用域分辨符::可以访问到父类中被隐藏的函数。

Parent parent;
Child  child;

parent.print();

child.Parent::print();
child.print();

2,当函数重写遇上赋值兼容性原则

你期望下面的程序输出什么？

#include <cstdlib>
#include <iostream>
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 run()
{
        Child child;
 
        Parent* pp = &child;
        Parent& rp = child;
 
        child.print();
        pp->print();
        rp.print();
}
 
int main()
{
        run();
        return 0;
}

结果是

i'm child..
i'm parent..
i'm parent..

为什么结果会是这个呢？

1，c++与c相同是静态编译型语言。

2，在编译时，编译器自动根据指针类型判断指向的是一个什么样的对象。

3，所以编译器认为父类指针指向的是父类对象

4，由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象。

5，从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数。

你可能会说这句话

Parent *pp = &child

明明指向child，为什么会说编译器不知道？

下面我们来看一个例子

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

假设我调用了这个函数，那么在编译这个函数的时候，编译器不可能知道指针p指向了什么。对吧

但是编译器也不能报错，所以编译器认为最好的做法就是编译父类的print函数，因为父类和子类都有相同的print函数啊。

3,多态的本质

1，面向对象的新需求

根据实际的对象类型来判断重新函数的调用

如果父类指针指向的是父类对象则调用父类中定义的函数。

如果父类指针指向的是子类对象则调用子类中定义的重写函数。

2，面向对象中的多态

根据实际的对象类型决定函数调用语句的具体调用目标

多态：同样的调用语句有多种不同的表现形态。

3，c++中多态的支持

c++通过虚函数virtual关键字对多态进行支持。

使用virtual声明的函数被重写后即可展现多态特性。

4，重写与重载

请看下面的例子？它的继承方式有问题吗？

#include <cstdlib>
#include <iostream>
using namespace std;
class Parent
{
     public: 
         virtual void func() 
         {
             cout<<"void func()"<<endl;
         }
          virtual void func(int i)
         {
            cout<<"void func(int i)"<<endl         }
         virtual void func(int i, int j)
         {
             cout<<"void func(int i, int j)"<<endl;
         }
};
class Child : public Parent
{
     public:
          void func(int i, int j)
         {
               cout<<"void func(int i, int j)"<<" "<<i + j<<endl;
          }
         void func(int i, int j, int k)
         {
              cout<<"void func(int i, int j, int k)"<<" "<<i + j + k<<endl;
         }
};  
void run(Parent* p)
{
    p->func(1, 2);
}
int main(int argc, char *argv[])
{
    Parent p;
    p.func();
    p.func(1);
    p.func(1, 2);
    Child c;
    c.Parent::func();
    run(&p);
    run(&c);

    return EXIT_SUCCESS;
}

函数重载：

必须在同一个类中进行

子类无法重载父类的函数。

重载时在编译期间根据参数类型和个数决定调用函数

函数重写：

必须发生于父类与子类之间。

并且父类与子类中的函数必须有完全相同的原型。

使用virtual声明之后能够产生多态。

多态是在运行期间根据具体对象的类型决定调用函数。