C++面向对象程序设计-北京大学-郭炜【课程笔记（八）】

最新推荐文章于 2024-05-25 21:56:33 发布
最新推荐文章于 2024-05-25 21:56:33 发布
阅读量1k 收藏 22
点赞数 8
分类专栏： C++ 文章标签： c++ 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54546190/article/details/138596159
版权

C++面向对象程序设计-北京大学-郭炜【课程笔记（八）】

开始课程：P28 1_1. 虚函数和多态的基本概念
课程链接：程序设计与算法（三）C++面向对象程序设计 北京大学 郭炜
课程PPT：github提供的对应课程PPT

1、虚函数和多态的基本概念

1.1、虚函数

  • 在类的定义中，前面有virtual关键字的成员函数就是虚函数。
class base
{
	virtual int get();
};
int base::get() {}
  • virtual关键字只用在类定义里的函数声明中，写函数体时不用。
    • 什么是函数体：函数体指的是函数定义中包含的代码块，用于实现函数的功能。 在函数定义中，通常会指定函数的名称、参数列表和返回值类型，而函数体则是具体实现函数功能的地方。
  • 构造函数和静态成员函数不能是虚函数

1.2、多态

多态的表现形式一

  • 派生类的指针可以赋给基类指针。
  • 通过基类指针调用基类和派生类中的同名虚函数时：
    • （1）、若该指针指向一个基类的对象，那么被调用是基类的虚函数；
    • （2）、若该指针指向一个派生类的对象，那么被调用的是派生类的许函数。
      以上这种机制就叫做“多态”。
#include <iostream>
using namespace std;

class CBase
{
    public:
        virtual void SomeVirtualFunction()
        {
            cout << "基类" << endl;
        }
};

class CDerived:public CBase
{
    public:
        virtual void SomeVirtualFunction()
        {
            cout << "派生类" << endl;
        }
};

int main()
{
    CDerived ODerived;
    CBase * p = & ODerived;
    // 调用哪个虚函数取决于p指向哪种类型的对象
    // 即派生类CDerived的对象
    p -> SomeVirtualFunction();  

    return 0;
}

OUT:
beida_lesson % g++ 25.cpp -o 25
beida_lesson % ./25 
派生类

多态的表现形式二

  • 派生类的对象可以赋值给基类引用
  • 通过基类引用调用基类和派生类中的同名虚函数时：
    • （1）、若该引用引用的是一个基类的对象，那么被调用时基类的虚函数
    • （2）、若该引用引用的是体格派生类的对象，那么被调用的是派生类的许函数。
      以上这种机制就叫做“多态”。
#include <iostream>
using namespace std;

class CBase
{
    public:
        virtual void SomeVirtualFunction()
        {
            cout << "基类" << endl;
        }
};

class CDerived:public CBase
{
    public:
        virtual void SomeVirtualFunction()
        {
            cout << "派生类" << endl;
        }
};

int main()
{
    CDerived ODerived;
    // 派生类的指针可以赋给基类指针
    // CBase * p = & ODerived;
    // p -> SomeVirtualFunction(); 

    //2、派生类的对象可以赋值给基类引用
    CBase & r = ODerived;
    r.SomeVirtualFunction();
    // 调用哪个虚函数取决于p\r指向哪种类型的对象
    // 即派生类CDerived的对象 

    return 0;
}
OUT:
beida_lesson % g++ 25.cpp -o 25
beida_lesson % ./25 
派生类

例：
在这里插入图片描述


int main()
{
    A a; B b; E e; D d;  
    A *pa = &a; B *pb = &b;
    D *pd = &d; E *pe = &e;

    pa -> Print();   // a.Print()被调用，输出：A::Print
    pa = pb;
    pa -> Print();   // b.Print()被调用，输出：B::Print
    pa = pd;
    pa -> Print();   // d.Print()被调用，输出：D::Print
    pa = pe;
    pa -> Print();   // e.Print()被调用，输出：E::Print

    return 0;
}

2、多态实例：魔法门之英雄无敌

在这里插入图片描述
请添加图片描述请添加图片描述请添加图片描述请添加图片描述

2.1、非多态的实现方法：

#include <iostream>
using namespace std;

class CCreature
{
    protected:
        int nPower;  // 代表攻击力
        int nLifeValue;  // 代表生命值2
};

class CDragon:public CCreature
{
    public:
        void Attack(CWolf * pWolf)
        {
            // 表现攻击动作的代码
            pWolf -> Hurted(nPower);
            pWolf -> FightBack(this);   // 表示Attack的对象：攻击的发起者
        }
        void Attack(CGhost * pGhost)
        {
            // 表现攻击动作的代码
            pGhost -> Hurted(nPower);
            pGhost -> FightBack(this);
        }
        void Hurted(int nPower)
        {
            // 表示受伤动作的代码
            nLifeValue -= nPower;
        }
        void FightBack(CWolf * pWolf)
        {
            // 表示反击动作的代码
            pWolf -> Hurted(nPower / 2);
        }
        void FightBack(CGhost * pGhost)
        {
            pGhost -> Hurted(nPower / 2);
        }
};

有n种怪物，CDragon类中就会有n个Attack成员函数，以及n个FightBack成员函数。对于其他类特使如此。

在这里插入图片描述

因为每个动物的攻击和反击方式不一样，所以不能直接在基类CCreature中定义Attack和FightBack成员函数。每一个动物要想攻击另一个动物必须含有攻击这个动物的成员函数，所以一旦添加新的怪物那么就需要在原有每个怪物类中添加Attack和FightBack两个成员函数。

2.2、多态的实现方法

请添加图片描述
请添加图片描述
请添加图片描述
在这里插入图片描述

3、多态实例：几何形体程序

3.1、qsort函数的介绍

qsort函数的声明

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*))
  • base – 指向要排序的数组的第一个元素的指针。
  • nitems – 由 base 指向的数组中元素的个数。
  • size – 数组中每个元素的大小，以字节为单位。
  • *compar：回调函数的函数指针，需要用户自己实现回调函数

3.2、几何形体程序

在这里插入图片描述在这里插入图片描述

#include <iostream>
#include <stdlib.h>
#include <math.h>

using namespace std;

class CShape
{
    public:
        virtual double Area() = 0; // 纯虚函数
        virtual void PrintInfo() = 0;
};

class CRectangle:public CShape
{
    public:
        int w,h;
        virtual double Area();
        virtual void PrintInfo();
};

class CCircle:public CShape
{
    public:
        int r;
        virtual double Area();
        virtual void PrintInfo();
};

class CTriangle:public CShape
{
    public:
        int a,b,c;
        virtual double Area();
        virtual void PrintInfo();
};

double CRectangle::Area()
{
    return w*h;
}

void CRectangle::PrintInfo()
{
    cout << "Rectangle" << Area() << endl;
}

double CCircle::Area()
{
    return 3.14*r*r;
}

void CCircle::PrintInfo()
{
    cout << "Rectangle" << Area() << endl;
}

double CTriangle::Area()
{
    double p = (a + b + c)/2.0;
    return sqrt(p*(p-a)*(p-b)*(p-c));
}

void CTriangle::PrintInfo()
{
    cout << "Traingle" << Area() << endl;
}

CShape * pShape[100]; // 基类的指针数组
int MyCompare(const void * s1, const void * s2)
{
    double a1, a2;   
    CShape * * p1;  // s1,s2是void *，不可写“* s1”来取得s1指向的内容
    CShape * * p2;  
    p1 = (CShape * *)s1;   // s1,s2指向pShape数组中的元素，数组元素的类型是CShape
    p2 = (CShape * *)s2;   // 故p1，p2都是指向指针的指针，类型为CShape **
    a1 = (*p1)->Area();    // * p1的类型是Cshape *，是基类指针，故此句为多态
    a2 = (*p2)->Area();
    if(a1<a2)
        return -1;
    else if(a2 < a1)
        return 1;
    else
        return 0;
}

int main()
{
    int i; int n;
    CRectangle * pr; CCircle * pc; CTriangle * pt;
    cout << "请输入几何形体的数量：" << endl;
    cin >> n;  // 输入几何形体的数量
    for(i=0; i<n; i++)
    {
        char c;
        cout << "请输入几何形体的种类R/C/T：" << endl;
        cin >> c;  // 输入几何形体的种类
        switch(c)
        {
            case 'R':
                pr = new CRectangle();  // new一个对象
                cout << "请输入矩形的长和宽w/h：" << endl;
                cin >> pr->w >> pr->h;
                pShape[i] = pr;
                break;
            case 'C':
                pc = new CCircle();
                cout << "请输入圆形的半径r：：" << endl;
                cin >> pc->r;
                pShape[i] = pc;
                break;
            case 'T':
                pt = new CTriangle();
                cout << "请输入三角形的三个边长a/b/c：" << endl;
                cin >> pt->a >> pt->b >> pt->c;
                pShape[i] = pt;
                break;
        }
    }
    qsort(pShape, n, sizeof(CShape*), MyCompare);
    for(i=0; i<n; i++)
    {
        pShape[i] -> PrintInfo();
    }
    return 0;
}

OUT
beida_lesson % ./27
请输入几何形体的数量：
3
请输入几何形体的种类R/C/T：
R
请输入矩形的长和宽w/h：
4
5
请输入几何形体的种类R/C/T：
C
请输入圆形的半径r：：
3
请输入几何形体的种类R/C/T：
T
请输入三角形的三个边长a/b/c：
3
4
5
Traingle6
Rectangle20
Rectangle28.26

3.2、铭记口诀

优点:

1、如果添加心得几何形体，比如五边形，则只需要从CShape派生出CPentagon，以及在main中的switch语句中增加一个case，其余部分不变有木有！
2、用基类指针数组存放指向各种派生类对象的指标，然后遍历该数组，就能对各个派生类对象做各种操作，是很常用的做法 。

铭记口诀：

1、派生类的指针可以赋值给基类指针
2、派生类的对象可以赋值给基类引用
3、用基类指针数组存放指向各种派生类对象的指标，然后遍历该数组，就能对各个派生类对象做各种操作，是很常用的做法 。

3.3、多态例题2:

#include <iostream>
#include <stdlib.h>
#include <math.h>

using namespace std;

class Base
{
    public:
        void fun1() {fun2();} 
        // 等于void fun1() {this->fun2();}
        // this是基类指针，fun2是虚函数，所以是多态
        virtual void fun2() {cout << "Base::fun2()" << endl;}
};

class Derived:public Base
{
    public:
        virtual void fun2() 
        {
            cout << "Derived:fun2()" << endl;
        }
};

int main()
{
    Derived d;
    Base * pBase = & d;
    // 这里pBase指针指向的是派生类的对象d，所以this指向的是派生类的fun2
    pBase->fun1();

    return 0;
}

OUT:
Derived:fun2()

在非构造函数，非析构函数的成员函数中调用虚函数，是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

  • 注意事项：派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数。

3.3、多态实例3:与构造函数

本节课程链接：看不懂对着课程就容易理解了，简单的。

  • 派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数
  • 构造函数和析构函数函数中调用虚函数不是多态
#include <iostream>
#include <stdlib.h>
#include <math.h>

using namespace std;

class myclass
{
    public:
        virtual void hello() {cout << "hello from myclass" << endl;};
        virtual void bye() {cout << "bye from myclass" << endl;}
};

class son:public myclass
{
    public:
        // 派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数
        void hello() {cout << "hello from son" << endl;}; // 也是虚函数
        son() {hello();};  // 构造函数和析构函数函数中调用虚函数不是多态
        ~son() {bye();};
};

class grandson:public son
{
    public:
        void hello() {cout << "hello from grandson" << endl;}; // 虚函数
        void bye() {cout << "bye from grandson" << endl;};     // 虚函数
        grandson() {cout << "constructing grandson" << endl;};
        ~grandson() {cout << "destructing grandson" << endl;};
};

int main()
{
    grandson gson;  // 派生类对象，先从基类先后的构造函数开始运行。
    son *pson;
    pson = &gson;
    pson->hello();  // 多态
    return 0;
}
//OUT
hello from son
constructing grandson
hello from grandson
destructing grandson
bye from myclass

4、多态的实现原理

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include<iostream>
using namespace std;

class A
{
    public:
        virtual void Func()
        {
            cout << "A::Func" << endl;
        }
};

class B:public A
{
    public:
        virtual void Func()
        {
            cout << "B::Func" << endl;
        }
};

int main()
{
    A a;
    A * pa = new B();
    pa -> Func();
    //64位程序指针位8字节
    long long * p1 = (long long *) & a;  // 强制类型转化为long long形
    long long * p2 = (long long *) pa;
    // 用class A虚函数表的地址替换掉派生类class B虚函数表的地址：因为虚函数表地址在前函数变量之前![请添加图片描述](https://img-blog.csdnimg.cn/direct/303255d7e6814f33b23c0d628d4990f0.png)

    * p2 = * p1;  
    pa -> Func();

    return 0;
}
// OUT
beida_lesson % ./30
B::Func
A::Func

5、虚析构函数、纯虚函数和抽象类

5.1、虚析构函数

请添加图片描述
对比案例如下所示：
请添加图片描述

5.2、纯虚函数和抽象类

  • 纯虚函数：没有函数体的虚函数
class A
{
	private: 
		int a;
	public:
		virtual void Print() = 0;  //  纯虚函数
		void fun() {cout << "fun" ;}
}
  • 包含纯虚函数的类叫抽象类
    在这里插入图片描述
#include<iostream>
using namespace std;

class A
{
    public:
        virtual void f() = 0; // 纯虚函数
        void g() {this->f()}; // OK,多态
        A() {
            // f();  //错误
        }
};

class B:public A
{
    public:
        void f() {cout << "B:f()"<<endl;}
};

int main()
{
    B b;
    b.g();
    return 0;
}
// OUT
B:f()

5.3、虚函数和纯虚函数的区别

  • 定义一个函数为虚函数，不代表函数为不被实现的函数。

  • 定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。

  • 定义一个函数为纯虚函数，才代表函数没有被实现。

  • 定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

☞源仔
关注
  • 8
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Coursera课程：C++程序设计-北京大学-郭炜、刘家瑛-编程作业1
08-08
Coursera课程：C++程序设计-北京大学-郭炜、刘家瑛-编程作业1
C++面向对象程序设计-北京大学-郭炜【课程笔记（五）】
源仔
03-08 1080
写毕业论文中：学习速度较慢。
C++面向对象程序设计-北京大学-郭炜【课程笔记（四）】
源仔
02-21 1077
普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用与某个对象。因此静态成员不需要通过对象就能访问。静态成员变量本质上是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在。静态成员函数本质上是全局函数。设置静态成员这种机制的目的是将和某些类紧密相关的全局变量和函数写到类里面，看上去像一个整体，易于维护和理解。
C++面向对象程序设计-北京大学-郭炜【课程笔记（六）】
源仔
04-13 759
毕业中：学习速度较慢 这节课内容相对较难理解，只做两章。
C++面向对象程序设计-北京大学-郭炜【课程笔记（十一）】
最新发布
源仔
05-25 428
容器类名::iterator 变量名；容器类名::const_iterator 变量名；* 迭代器变量名迭代器上可以执行++操作，以使其指向容器中的下一个元素。如果迭代器到达了容器中的最后一个元素的后面，此时再使用它，则会报错，类似于使用NULL或未初始化的指针一样。int main()// 一个存放int元素的数组，一开始里面没有元素// 常用迭代器i!= v.end();i++)// 反向迭代器r!=v.rend();r++)// 非常量迭代器j!= v.end();
C++面向对象程序设计-北京大学-郭炜【课程笔记（二）】
源仔
02-15 1088
Init函数作用在r2上，即Init函数执行期间访问的w和h是属于r2这个对象的，执行r2.Init不会影响到r1。”，从而使得数据结构和操作该数据结构的算法呈现出显而易见的紧密关系，这就是“面向对象的程序设计具有“抽象”，“封装”，“继承”，“多态”四个基本特点。然后，通过某种语法形式，将数据结构和操作该数据结构的函数“和结构变量一样，对象之间可以用 “=” 进行赋值，但是。，进行比较，除非这些运算符经过了“重载”。通过类，可以定义变量。，也称为类的实例，就是我们所说的。”在一起，形成一个“
C++面向对象程序设计-北京大学-郭炜【课程笔记（一）】
源仔
02-14 937
函数重载一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫函数的重载。作用函数重载使得函数命名变得简单。编译器根据调用语句中的实参的个数和类型判断应该调用哪个函数。// 调用（1）Max(2,4);// 调用（2）// 调用（3）// error，二义性。
C++面向对象程序设计-北京大学-郭炜【课程笔记（七）】
源仔
04-18 1109
毕业中：学习速度较慢。
C++面向对象程序设计-北京大学-郭炜【课程笔记（九）】
源仔
05-14 668
/ aa和bb之间相隔一个制表符输出输出：aa bb上面为何能这样输出呢！因为iostream里对
C++面向对象程序设计-北京大学-郭炜【课程笔记（三）】
源仔
02-17 1016
public://动态分配的内存空间，需要释放，在析构函数中释放。
新标准C++程序设计教材答案郭炜.pdf
01-29
新标准C++程序设计教材答案郭炜.pdf
新标准C++程序设计教材11-20章课后题答案
11-14
C++新标准C++程序设计—郭炜答案,答案非常齐全。
新标准C++习题解答chapter11-20.pdf
06-16
《新标准C++程序设计》（高等教育出版社）郭炜，课本习题答案，中国大学mooc课程里可免费下载
新标准C++程序设计教程习题解答.pdf
08-16
郭炜老师的C++教程的配套答案，尽管是pdf格式的，但是是文字录入的，不是扫描的，会用的同学们知道怎么用。
C语言 变量的存储类型
weixin_45966674的博客
05-21 479
今天 我们来说变量的存储类型变量的存储类型是指系统为变量分配存储区域的方式。决定着变量存储空间在哪里分配，和变量的生存期、作用域存在着一定联系。
C语言——函数指针与指针函数
qq_67319052的博客
05-19 639
函数指针与指针函数有什么区别？
C/C++免杀--原生态(GG)
金灰的博客
05-20 394
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
【C++】初始化列表
qq_46049113的博客
05-19 168
当创建一个类的实例时，类的构造函数会被调用来初始化该实例。构造函数可以通过其体（即大括号内的代码部分）或通过初始化列表来初始化成员变量。：使用初始化列表可以直接初始化成员变量，而不是先默认构造成员然后再赋值。：对于常量成员变量和引用成员，初始化列表是必需的，因为这些类型的成员一旦创建后就不能再被赋值。：如果一个类继承自基类，或者它包含其他类的对象作为成员，这些基类和成员对象只能通过初始化列表进行初始化。这种初始化方式确保了代码的效率和成员变量的正确设置，特别是在涉及复杂类型或类的资源管理时尤为重要。
郭炜编著《python程序设计基础及实践(慕课版)》
09-02
《Python程序设计基础及实践(慕课版)》是由郭炜编著的一本教材。本书主要面向初学者，旨在帮助读者掌握Python编程语言的基础知识和实践技能。 《Python程序设计基础及实践(慕课版)》全书共分为数个部分，内容包括Python的基本语法、常用数据类型和数据结构、条件和循环语句、函数、文件操作、异常处理等。每一章节设计了大量的例子和练习题，读者可以通过实践来巩固所学的知识。 该书注重代码实践，通过实际案例和项目来讲解Python编程的实际应用。通过慕课视频配套教学，读者可以更好地理解和掌握书中的知识点。本书的编写风格通俗易懂，适合初学者阅读。 《Python程序设计基础及实践(慕课版)》的特点在于注重实践和案例，通过大量的实例和练习来帮助读者巩固所学的知识。同时，该书还涵盖了Python编程的一些进阶内容，如Web开发、数据分析和人工智能等，读者可以根据自己的需求选择学习的方向。 总之，《Python程序设计基础及实践(慕课版)》是一本适合初学者学习Python的教材，通过案例和项目帮助读者实践所学的知识，并且涵盖了一些进阶内容，读者可以选择不同的方向深入学习。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

☞源仔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值