C++技能进阶指南——多态语法剖析

CSDN 2024-07-24 12:35:02 阅读 62

        前言:多态是面向对象的三大特性之一。顾名思义, 多态就是多种状态。 那么是什么的多种状态呢? 这里的可能有很多。比如我们去买火车票, 有普通票, 学生票; 又比如我们去旅游, 有儿童票, 有成人票等等。 这些都是多态的例子。 具体转化为我们的编程思想就是:让不同类型的对象去完成相同的事, 这就是多态

        本篇内容主要讲述多态, 多为语法方面的知识点。 适合已经学完继承的友友们观看。

        

目录

一、多态的相关概念

1.1虚函数

1.2虚函数的重写

1.3虚函数重写的两个例外

 1.4override 和 final 的使用

二、重载、重写、隐藏(重定义)的区别

三、如何构成多态

四、抽象类

五、普通继承和接口继承

六、静态绑定和动态绑定


具体什么是多态在前言中已经提到, 正文部分不做赘述。

一、多态的相关概念

1.1虚函数

        被virtual关键字修饰的成员函数叫做虚函数。 例如:

<code>//A位基类

class A

{

public:

virtual void func() //定义一个虚函数

{

cout << "Afunc()" << endl;

}

};

         需要注意的是, 对于构造函数和析构函数来说。 析构函数可以是虚函数, 但是构造函数不可以是虚函数。 

具体原因如下:(建议看完整篇文章和总结虚函数表机制——c++多态底层原理-CSDN博客​​​​​​ 之后再来看下面这段解释):

        首先:通过之前的学习, 我们知道了, 虚函数的地址是存在虚函数表里面的。 想要调用对应的虚函数, 我们需要先去虚函数表中寻找对应虚函数的地址。 但是虚函数表是在构造函数的初始化列表初始化的。如果构造函数是虚函数, 那么调用构造函数的时候就找不到。 所以构造函数没办法是虚函数。

1.2虚函数的重写

        虚函数的重写就是: 在派生类当中, 有一个和基类中某一个虚函数函数头的虚函数(函数头就是:函数的返回值, 函数名, 函数的参数列表)。 这个时候就会构成虚函数的重写, 即 子类重写了基类的虚函数

//A位基类

class A

{

public:

virtual void func()

{

cout << "Afunc()" << endl;

}

};

//B类继承A类

class B : public A

{

public:

//重写A类的func函数

virtual void func() //注意, 这里的virtual可以不写, 因为编译器默认这里是加了virtual的

{

cout << "Bfunc()" << endl;

}

};

        需要注意的是, 上图中派生类的func可以不加virtual, 因为基类的func是虚函数, 编译器会默认派生类中和他函数头相同的函数也是虚函数。 

1.3虚函数重写的两个例外

        协变:派生类在重写基类的虚函数的时候, 与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用, 派生类虚函数返回派生类对象的指针或者引用的时候, 成为协变。

//A位基类

class A

{

public:

virtual A* func()

{

cout << "Afunc()" << endl;

}

};

//B类继承A类

class B : public A

{

public:

//重写A类的func函数

virtual B* func()

{

cout << "Bfunc()" << endl;

}

};

//C类继承A类

class C : public A

{

virtual C* func()

{

cout << "Cfunc" << endl;

}

};

    

        析构函数的重写: 基类析构函数如果加了virtual, 那么说明基类的析构函数为虚函数。 这个时候如果派生类的析构函数也就变成了虚函数。 那么成不成为虚函数对于析构函数来说有什么不同呢?

        首先我们需要知道的是, 在一个普通的类之中, 编译器其实将析构函数统一处理成为了destructor。

        然后, 对于一个派生类来说, 如果它的析构函数不是虚函数。 当我们使用父类的指针构成多态时, 只会析构派生类的一部分:

//A位基类

class A

{

public:

virtual A* func()

{

cout << "Afunc()" << endl;

}

//其他动态内存分配的空间

//int* ...

//double* ...

};

//B类继承A类

class B : public A

{

public:

//重写A类的func函数

virtual B* func()

{

cout << "Bfunc()" << endl;

}

//其他动态内存分配的空间

//int* ...

//double* ...

};

void test_func(A* p)

{

p->func();

}

int main()

{

C c;

A* p = nullptr;

p = &c;

delete p;

return 0;

}

         如上图, 假如delete p, 那么就只能释放属于C类自己的那一部分。那么属于A类的那一部分将得不到释放。 

        但是, 如果我们对A类的析构函数使用虚函数。 那么派生类的析构函数也变成了虚函数, 这个时候如果再形成多态。delete p就能将A类和C类都释放掉。

//A位基类

class A

{

public:

virtual A* func()

{

cout << "Afunc()" << endl;

}

virtual ~A()

{}

};

//B类继承A类

class B : public A

{

public:

//重写A类的func函数

virtual B* func()

{

cout << "Bfunc()" << endl;

}

virtual ~B()

{}

};

 1.4override 和 final 的使用

先谈override, override是用来检验某个虚函数是否构成了重写。如果没有构成重写, 那么编译器就会报错。

        如下为构成重写:

//A位基类

class A

{

public:

virtual void func()

{

cout << "Afunc()" << endl;

}

};

//B类继承A类

class B : public A

{

public:

//重写A类的func函数

virtual void func() override

{

cout << "Bfunc()" << endl;

}

};

如下为没有构成重写:

<code>

//A位基类

class A

{

public:

void func()

{

cout << "Afunc()" << endl;

}

};

//B类继承A类

class B : public A

{

public:

//重写A类的func函数

virtual void func() override

{

cout << "Bfunc()" << endl;

}

};

二、重载、重写、隐藏(重定义)的区别

重载: 函数处于相同作用域内, 并且函数的函数名相同, 参数不同。重写: 函数分别处于基类和派生类中,并且都是虚函数, 并且有相同的函数头隐藏: 继承体系中函数分别处在基类和派生类的作用与之中, 不是虚函数,并且都具有相同的函数头

三、如何构成多态

        要形成多态有两个条件:

一、虚函数的重写。二、父类的指针指向子类,或者父类的引用引用子类对象。

        如下为一个多态的实例:

<code>//A位基类

class A

{

public:

virtual void func()

{

cout << "Afunc()" << endl;

}

};

//B类继承A类

class B : public A

{

public:

virtual void func()

{

cout << "Bfunc()" << endl;

}

};

//C类继承A类

class C : public A

{

virtual void func()

{

cout << "Cfunc" << endl;

}

};

int main()

{

C c;

B b;

A* p = nullptr;

p = &c;

p->func();

p = &b;

p->func();

return 0;

}

         在这串代码中, B类和C类都是A类的派生类。 他们都有对A类中的虚函数func进行重写, 满足条件一。 

        然后基类的指针p先是指向了C类的对象。 又指向了B类的对象。 构成了父类的指针指向子类, 满足条件二。

        所以, 这就是一个多态。

其实, 多态的应用场景多为这样:

<code>

//A位基类

class A

{

public:

virtual void func()

{

cout << "Afunc()" << endl;

}

};

//B类继承A类

class B : public A

{

public:

virtual void func()

{

cout << "Bfunc()" << endl;

}

};

//C类继承A类

class C : public A

{

virtual void func()

{

cout << "Cfunc" << endl;

}

};

void test_func(A* p)

{

p->func();

}

int main()

{

C c;

B b;

test_func(&b);

test_func(&c);

return 0;

}

        这样, 通过传送不同类型的对象给test_func函数, 就能构成多态。

四、抽象类

        如果一个虚函数后面加上 =0, 那么这个虚函数就是纯虚函数, 并且包含这个纯虚函数的类叫做抽象类。

        抽象类不能实例化对象。

//A位基类

class A

{

public:

virtual void func() = 0;

};

int main()

{

A a;

return 0;

}

但是A的派生类如果重写了纯虚函数, 那么就可以这个派生类就可以实例化处对象。

但是如果A的派生类没有重写纯虚函数, 那么这个派生类同样不能实例化处对象。

<code>

//A位基类

class A

{

public:

virtual void func() = 0;

};

//B类继承A类

class B : public A

{

public:

//重写A类的func函数

};

int main()

{

B b;

return 0;

}

五、普通继承和接口继承

        普通继承:在继承体系中, 派生类继承了基类的函数, 能够直接使用的是普通继承, 这类继承继承的是基类函数的实现。 

        接口继承:如果继承了基类的虚函数, 并且重写实现了多态。 那么就是一种接口继承, 多态的体系是一种接口的继承, 具体的函数实现是由派生类自己实现的。

六、静态绑定和动态绑定

        静态绑定: 静态绑定又被成为前期绑定,  当程序在编译的时候确定的要调用的函数, 确定了程序要执行的行为, 这个过程成为静态多态。 比如我们使用的函数重载就是静态的多态。

        动态绑定: 动态绑定又被成为后期绑定, 当程序在编译之后也就是运行期间根据不同的对象调用不同的函数。 这个过程叫做动态多态, 也就是多态。

------------------------------------------------------

ps: 本篇内容没有讲解多态的原理, 因为多态的原理其实就是虚函数表。 而虚函数表的详细讲解博主之前已经写过一篇: 总结虚函数表机制——c++多态底层原理-CSDN博客 。

        在这篇文章中, 博主用自己的理解讲解的虚函数表的机制与实现。 写的不甚严谨, 但是里面的结论却是博主通过调试一步一步验证的来的。感兴趣的友友们可以看一下。

后续补带有虚函数的类的内存大小的计算(暂时有点模糊, 先不写, 而且最近考试比较多。可能要等暑假才能补上这一板块)。



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。