慕课网-C++远征之多态篇（上）-学习笔记

最新推荐文章于 2021-02-27 16:15:53 发布
最新推荐文章于 2021-02-27 16:15:53 发布
阅读量148 收藏
点赞数
文章标签： c/c++
原文链接：https://yq.aliyun.com/articles/631021
版权

C++远征之多态篇

面向对象三大特征：封装，继承，多态

多态：发出一条命令时，不同的对象接收到同样的命令做出的动作不同

目录：

  1. 普通虚函数 & 虚析构函数
  2. 纯虚函数：抽象类 & 接口类
  3. RTTI（运行时类型识别）
  4. 异常处理
  5. 概念：隐藏 & 覆盖 | 早绑定与晚绑定
  6. 虚函数表

多态的内容很多，概念也听起来有点变态

多态变态

不过这也是最精彩的部分了。

c++ 虚函数

什么是多态

多态是指相同对象收到不同消息或不同对象收到相同消息时产生不同的动作

静态多态 & 动态多态

  • 静态多态（早绑定）
  • 动态多态（晚绑定）
静态多态：相同对象收到不同消息

例子：

class Rect
{
public:
    int calcArea(int width);
    int calcArea(int width,int height);//互为重载
}

int main(void)
{
    Rect rect;
    rect.calcArea(10);
    rect.calcArea(10,20);

    return 0;
}

当我们传入一个参数，两个参数会调用两个不同的同名函数。
计算机在编译阶段就会自动根据参数使用不同的确定使用哪个函数。

动态多态（晚绑定）：不同对象收到相同消息
动态多态-一消息：多对象。

动态多态：必须以封装与继承为基础。

代码例子：

class Shape
{
public:
    double calcArea()
    {
        cout << "calcArea" <<endl;
        return 0;
    }
}

class Circle:public Shape
{
public:
    Circle(double r);
    double calcArea();
private:
    double m_dR;
}
//实现
double Circle::calcArea()
{
    return 3.14 * m_dR * m_dR;
}
//矩形
class Rect::public Shape
{
public:
    Rect(double width,double height);
    double calcArea();
private:
    double m_dWidth;
    double m_dHeight;
}

//实现
double Rect::calcArea()
{
    return m_dWidth * m_dHeight;
}

main函数中的使用：

int main()
{
    Shape *shape1 = new Circle(4.0);
    Shape *shape2 = new Rect(3.0,5.0);
    shape1 -> calcArea();
    shape2 -> calcArea();
    //...
    return 0;
}

上述代码会调用两次父类的clacArea();

  • 使用父类指针指向子类对象，子类与父类有同名函数，加virtual成为虚函数，则调用相同的函数名的时候调用的是子类的函数.不添加的时候，使用父类指针指向的是父类自身的calc。
virtual 虚函数
class Shape
{
public:
    virtual double calcArea() //虚函数
    {
        cout << "calcArea" <<endl;
        return 0;
    }
}
  • 子类中不加也可以，不过如果考虑子类也有可能成为父类情况下也加上。

加上virtual后，父类指针指向子类对象。子类与父类有同名函数。父类指针可以使用子类方法。

  • 如果是用父类指针，不加virtual关键字的话就会调用父类，如果是用子类指针，则调用子类，因为造成了隐藏
虚函数代码示例
虚函数：要求
未使用virtual时,调用两遍父类的

上图为shape的析构函数添加了virtual。因此销毁父类指针，会将子类的也一并销毁。

附录代码：

#ifndef SHAPE_H
#define SHAPE_H

#include <iostream>
using namespace std;

class Shape
{
public:
    Shape();
    virtual ~Shape();
    virtual double calcArea();
};


#endif


//
//
#include "Shape.h"


Shape::Shape()
{
    cout << "Shape()" << endl;
}

Shape::~Shape()
{
    cout << "~Shape()" << endl;
}

double Shape::calcArea()
{
    cout << "Shape - > calcArea()" << endl;
    return 0;
}

//
//
#ifndef RECT_H
#define RECT_H

#include "Shape.h"
class Rect : public Shape
{
public:
    Rect(double width,double height);
    ~Rect();
    double calcArea();

protected:
    double m_dwidth;
    double m_dHeight;
};
#endif // RECT_H


//
//
#include "Rect.h"

Rect::Rect(double m_dwidth, double m_dHeight)
{
    cout << "Rect()" << endl;
    this->m_dHeight = m_dHeight;
    this->m_dwidth = m_dwidth;
}

Rect::~Rect()
{
    cout << "~Rect()" << endl;
}

double Rect::calcArea()
{
    cout << "Rect::calcArea()"<< endl;
    return m_dwidth * m_dHeight;
}

//
//
#ifndef CIRCLE_H
#define CIRCLE_H

#include "Shape.h"
class Circle:public Shape
{
public:
    Circle(double r);
    ~Circle();
    double calcArea();
protected:
    double m_dR;
};
#endif

//
//
#include "Circle.h"


Circle::Circle(double r)
{
    cout << "Circle()" << endl;
    m_dR = r;
 }

Circle::~Circle()
{
    cout << "~Circle()" << endl;
}
double Circle::calcArea()
{
    cout << "Circle-->calcArea()" << endl;
    return 3.14 * m_dR * m_dR;
}

//
//
#include <iostream>
#include "Circle.h"
#include "Rect.h"
#include <stdlib.h>
using namespace std;

int main()
{
    Shape *shape1 = new Circle(3.0);
    Shape *shape2 = new Rect(3.0, 4.0);
    shape1->calcArea();
    shape2->calcArea();
    //当基类不添加virtual时。打印两遍基类的。
    delete shape1;
    shape1 = NULL;
    delete shape2;
    shape2 = NULL;
    system("pause");
    return 0;
}

在给shape的clacArea函数加上virtual后。可调用子类的成员函数。

shape的calcArea函数加上virtual后

推荐为子类也加上virtual。

虚析构函数

动态多态的内存泄漏

class Shape
{
public:
    Shape();
    virtual double calcArea();

} 


class Circle: public Shape
{
public:
    Circle(int x,int y,double r);
    ~Circle();
    virtual double calcArea();

private:
    double m_dR;
    Coordinate *m_pCenter;//圆心坐标
}


//构造函数圆心坐标：
//
Circle::Circle(int x,int y,double r)
{
    m_pCenter = new Coordinate(x,y);
    m_dR = r;
}
Circle::~Circle()
{
    delete m_pCenter;
    m_pCenter = NULL;
}

上述代码我们可以实现堆中内存的释放。

但是在多态中：

int main(void)
{
    Shape *shape1 = new Circle(3,5,4.0)
    shape1 -> calcArea();
    delete shape1;
    shape1 = NULL;
    return 0;
}

上述代码在shape的析构函数未添加virtual时将只会释放Shape对象。而实例化出的Circle对象不会被销毁。

  • delete后面跟着父类的指针。只会执行父类的析构函数。
  • 跟着子类，会先执行子类，然后执行父类。
virtual -> 析构函数

只需要在基类的析构函数添加virtual。父类指针可以一起销毁掉子类的对象。

virtual在函数中的使用限制

  • 普通函数不能是虚函数。（必须是类的成员函数，不能是全局函数）
  • 静态成员函数不能是虚函数
class Animal
{
public:
    virtual static int getCount()//因为被修饰过的静态函数是类的，不属于任何一个对象。
}
  • 内联函数不能是虚函数

会忽略inline。使他变成一个纯虚函数。

class Animal
{
public:
    inline virtual int eat()
    {

    }
}
  • 构造函数不能是虚函数
虚析构函数使用方法代码示例
虚析构函数要求

shape.h:

#ifndef SHAPE_H
#define SHAPE_H

#include <iostream>
using namespace std;

class Shape
{
public:
    Shape();
    virtual ~Shape();
    virtual double calcArea();
};


#endif

Shape.cpp

#include "Shape.h"


Shape::Shape()
{
    cout << "Shape()" << endl;
}

Shape::~Shape()
{
    cout << "~Shape()" << endl;
}

double Shape::calcArea()
{
    cout << "Shape - > calcArea()" << endl;
    return 0;
}

rect.h:

#ifndef RECT_H
#define RECT_H

#include "Shape.h"
class Rect : public Shape
{
public:
    Rect(double width,double height);
    ~Rect();
    double calcArea();

protected:
    double m_dwidth;
    double m_dHeight;
};
#endif // RECT_H

rect.cpp：

#include "Rect.h"

Rect::Rect(double m_dwidth, double m_dHeight)
{
    cout << "Rect()" << endl;
    this->m_dHeight = m_dHeight;
    this->m_dwidth = m_dwidth;
}

Rect::~Rect()
{
    cout << "~Rect()" << endl;
}

double Rect::calcArea()
{
    cout << "Rect::calcArea()"<< endl;
    return m_dwidth * m_dHeight;
}

circle.cpp:

#ifndef CIRCLE_H
#define CIRCLE_H

#include "Shape.h"
#include "Coordinate.h"
class Circle:public Shape
{
public:
    Circle(double r);
    ~Circle();
    double calcArea();
protected:
    double m_dR;
    Coordinate *m_pCenter;
};
#endif

circle.cpp:

#include "Circle.h"


Circle::Circle(double r)
{
    cout << "Circle()" << endl;
    m_dR = r;
    m_pCenter = new Coordinate(3, 5);
 }

Circle::~Circle()
{

    cout << "~Circle()" << endl;
    delete m_pCenter;
    m_pCenter = NULL;
}
double Circle::calcArea()
{
    cout << "Circle-->calcArea()" << endl;
    return 3.14 * m_dR * m_dR;
}

Coordinate.h :

#ifndef COORDINATE_H
#define COORDINATE_H
#include <iostream>

using namespace std;

class Coordinate
{
public:
    Coordinate(int x, int y);
    ~Coordinate();
private:
    int m_iX;
    int m_iY;
};

#endif

Coordinate.cpp:

#include "Coordinate.h"
#include <iostream>
using namespace std;

Coordinate::Coordinate(int x, int y)
{
    cout << "Coordinate()" << endl;
    m_iX = x;
    m_iY = y;
}
Coordinate::~Coordinate()
{
    cout << "~Coordinate()" << endl;

}

main.cpp:

#include <iostream>
#include "Circle.h"
#include "Rect.h"
#include <stdlib.h>
using namespace std;

int main()
{
    Shape *shape2 = new Rect(3.0, 4.0);
    Shape *shape1 = new Circle(3.0);
    shape1->calcArea();
    shape2->calcArea();
    //当基类不添加virtual时。打印两遍基类的。
    delete shape1;
    shape1 = NULL;
    delete shape2;
    shape2 = NULL;
    system("pause");
    return 0;
}

给shape的析构函数变成一个虚析构函数。推荐大家把子类的虚析构函数。因为子类也有可能成为其他类的父类。

shape的虚析构函数帮助继承于他的对象一起销毁
virtual限制情况
virtual Shape();
//“inline”是构造函数的唯一合法存储类

virtual void test() {
//error C2575: “test”: 只有成员函数和基可以是虚拟的
}

class Shape
{
public:
    Shape();
    //error C2216: “virtual”不能和“static”一起使用
    virtual static void test();
    virtual ~Shape();
    virtual double calcArea();
};

inline会失效：

virtual inline void test() {

    }
练习题
  • 虚函数特性可以被继承，当子类中定义的函数与父类中虚函数的声明相同时，该函数也是虚函数。
  • 虚函数使用virtual关键字定义，但使用virtual关键字时，并非全部是虚函数
  • 虚析构函数是为了避免使用父类指针释放子类对象时造成内存泄露。

虚函数与虚析构函数原理

如何实现虚函数和虚析构函数：虚函数的实现原理

函数指针

指针指向对象 - - - 对象指针
指针指向函数 - - - 函数指针

指针指向代码的开头，然后一行一行执行到函数结尾

函数指针

指针指向代码内存的首地址。

class Shape
{
public:
    virtual double calcArea() //虚函数
    {
        return 0;
    }
protected:
    int m_iEdge;
}

//子类

class Circle: public Shape
{
public:
    Circle(double r);
    //circe使用的也是Shape的虚函数
private:
    double m_dR;
}
虚函数表指针

当我们实例化一个shape对象时。shape中除了数据成员m_iEdge还有另外一个成员（虚函数表指针：也是指针占有四个内存单元）。指向一个虚函数表。该表会与shape类的定义同时出现。在计算机中虚函数表占有一定空间。假设虚函数表的起始位置：0xCCFF.那么虚函数表指针的值就是0xCCFF。父类的虚函数表只有一个。通过父类实例化出的多个对象。虚函数表指针都只有一个。0xCCFF.父类的虚函数表中定义了一个函数指针->指向calcArea()的入口地址。

Circle实例化时虚函数表指针

Circle中并没有定义虚函数，但是他却从父类中继承了虚函数。所以我们在实例化Circle也会产生一个虚函数表指针。他是Circle自己的。在Circle中计算面积的方法首地址与父类的一致。这使得在Circle中访问父类的计算面积函数也能通过虚函数表指针找到自己的虚函数表。在自己的虚函数表中找到的也是指向父类的计算面积的。

如果我们在circle中定义了计算面积的函数：

class Circle: public Shape
{
public:
    Circle(double r);
    virtual double calcArea();
private:
    double m_dR;
}

shape没有发生变化。

虚函数表指针

对于Circle来说则有变化：

Circle自有父类虚函数

此时Circle中关于计算面积的指针指向自己的方法首地址。
0X6688中的calcArea_ptr已经指向了自己的。

函数的覆盖与隐藏

父类和子类出现同名函数。称之为隐藏。

  • 如果没有在子类中定义同名虚函数。那么子类的虚函数表指针会写上父类函数的地址。
  • 如果在子类中也定义了同名的虚函数。那么将覆盖并指向子类。

上面这种情况称之为函数的覆盖。

虚析构函数原理。

特点：在父类中通过virtual修饰析构函数。通过父类指针指向子类对象。那么释放父类指针，可以同时释放子类对象。

理论前提：

执行完子类的析构函数就会执行父类的析构函数。
只要我们可以实现执行子类的析构函数。

class Shape
{
public:
    virtual double calcArea() //虚函数
    {
        return 0;
    }
    virtual ~Shape(){} //虚析构函数
protected:
    int m_iEdge;
}

class Circle: public Shape
{
public:
    Circle(double r);
    virtual double calcArea();
    virtual ~Circle();//不写计算机也会自行定义

private:
    double m_dR;
}

//main.cpp:
//

int main()
{
    Shape *shape = new Circle(10.0);
    delete shape;
    shape = NULL;

    return 0;
}
虚析构函数如何运作

如果我们在父类中定义了虚析构函数。那么我们在父类当中的虚函数表中就会有一个父类的析构函数的函数指针。

子类的虚析构函数表

那么子类的虚函数表中也会有一个函数指针，指向子类的析构函数。这个时候使用父类对象指向子类对象。就会销毁子类与父类的对象。

虚析构函数与上面虚函数是同理可得的，就是子类中有同名对象，那么这个虚函数表中指针将指向子类的函数。而因为子类析构函数执行会触发父类执行。所以实现了销毁父类指针，释放子类和父类的对象。

  • 比如此时我们删去子类的析构函数。那么将只执行父类的析构函数。

证明虚函数表指针的存在（代码示例）

虚函数表指针要求
  • 对象的大小：在类实例化的对象当中数据成员所占据的大小。不包括成员函数
  • shape没有数据成员（理论上不占），Circle有数据成员int型。应该占四个。
  • 对象的地址：通过类实例化的对象在内存单元中占据的首地址
  • 对象成员的地址：当用一个类实例化一个对象之后，这个对象中可能与一个或多个数据成员，每一个数据成员所占据的地址就是这个对象的成员地址，对象的数据成员由于数据类型不同那么占据的内存大小也不同，地址也是不同的。
  • 虚函数表指针：在具有虚函数的情况下实例化对象时，这个对象的第一个内存存储的是一个指针，即虚函数表的指针，占四个内存单元，因此我们可以通过计算对象的大小来证明指针的存在。
#ifndef SHAPE_H
#define SHAPE_H

#include <iostream>
using namespace std;

class Shape
{
public:
    Shape();
    ~Shape();
    double calcArea();
    //virtual ~Shape();
    //virtual double calcArea();
};


#endif

//cpp
#include "Shape.h"


Shape::Shape()
{
    //cout << "Shape()" << endl;
}

Shape::~Shape()
{
    //cout << "~Shape()" << endl;
}

double Shape::calcArea()
{
    cout << "Shape - > calcArea()" << endl;
    return 0;
}

#ifndef CIRCLE_H
#define CIRCLE_H

#include "Shape.h"
#include "Coordinate.h"
class Circle:public Shape
{
public:
    Circle(int r);
    ~Circle();
protected:
    int  m_iR;
};
#endif


//cpp:
//
#include "Circle.h"


Circle::Circle(int r)
{
    m_iR = r;
 }

Circle::~Circle()
{

}

main.cpp:

#include <iostream>
#include "Circle.h"
#include "Rect.h"
#include <stdlib.h>
using namespace std;

int main()
{
    Shape shape;
    cout << sizeof(shape) << endl;
    //shape对象没有任何的数据成员。理论应该为0.
    Circle circle(100);
    cout << sizeof(circle) << endl;
    //int 理论为4.

    system("pause");
    return 0;
}

运行结果：

证明的运行结果

4是因为int占四个字节。如何解释1？

  • 在没有一个数据成员的情况下，c++会给该对象1个内存单元来标记此对象的地址，
  • 而对于含有内存单元的对象来说，他的大小则是该数据成员的大小

main.cpp:

#include <iostream>
#include "Circle.h"
#include "Rect.h"
#include <stdlib.h>
using namespace std;

int main()
{
    Shape shape;
    int *p = (int *)&shape;
    //强制类型转换
    cout << p << endl;
    Circle circle(100);

    int *q = (int *)&circle;
    cout << q << endl;
    //shape和Circle对象在内存中地址不同。
    cout << (unsigned int)(*q) << endl;
    //打印出里面存着的值
    system("pause");
    return 0;
}

运行结果：

两对象指向不同地址，指针直接访问内部值
虚函数示例2
class Shape
{
public:
    Shape();
    ~Shape();

    //virtual ~Shape();
    virtual double calcArea();
};


int main()
{
    Shape shape;
    cout << sizeof(shape) << endl;
    int *p = (int *)&shape;//强制类型转换
    cout << p << endl;
    
    Circle circle(100);
    int *q = (int *)&circle;
    cout << q << endl;
    //shape和Circle对象在内存中地址不同。
    cout << (unsigned int)(*q) << endl;
    //打印出里面存着的值
    system("pause");
    return 0;
}

运行结果：

指针占四个

当我们使shape拥有一个虚函数时。

  • 指向Shape的指针应该指向一个虚拟函数表。
  • 因为是个指针，所以占四个内存空间。

shape.h:

class Shape
{
public:
    Shape();
    double calcArea();
    virtual ~Shape();虚析构函数也有虚函数表。
};

运行结果：

虚析构-虚表-四个 
int main()
{
    Shape shape;
    cout << sizeof(shape) << endl;
    int *p = (int *)&shape;//强制类型转换
    //cout << p << endl;
    
    Circle circle(100);
    cout << sizeof(circle) << endl; 
    //虚函数指针父类有了子类也会有。所以应该是8
    int *q = (int *)&circle;
    cout << q << endl;
    //shape和Circle对象在内存中地址不同。
    cout << (unsigned int)(*q) << endl;
    //打印出里面存着的值
    system("pause");
    return 0;
}

运行结果：

父类指针4个，子类：4+4

8 为int 4 & 虚函数表指针4


int main()
{
        Shape shape;
        int *p = (int *)&shape;
        cout << (unsigned int)(*p) << endl;
        //虚函数表地址
        //
        Circle circle(100);
        int *q = (int *)&circle;
        cout << (unsigned int)(*q) << endl;
        //打印出的还是虚函数表地址


}

运行结果：

父类&子类虚函数表地址 
int *q = (int *)&circle;
q++;
cout << (unsigned int)(*q) << endl;

输出结果为100.说明：

  • circle指针8位。前四位是指针指向虚地址表首地址。后四位是里面存着的内容。
  • 父类和子类拥有不同的属于自己的虚函数表。

练习；

  • 在C++中多态的实现是通过虚函数表实现的
  • 每个类只有一份虚函数表，所有该类的对象共用同一张虚函数表
  • 两张虚函数表中的函数指针可能指向同一个函数。(当子类没有父类的同名函数)

巩固练习：

定义一个动物（animal）类，要求含有虚函数eat和move，并定义构造函数和虚析构函数
定义一个狗（Dog）类，要求共有继承动物类，定义构造函数和虚析构函数，并实现自己的eat和move函数
使用父类对象实例化子类，调用子类成员函数

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 *  定义动物类：Animal
 *  成员函数：eat()、move()
 */
class Animal
{
public:
    // 构造函数
    Animal(){cout << "Animal" << endl;}
    // 析构函数
    virtual  ~Animal(){cout << "~Animal" << endl;}
    // 成员函数eat()
    virtual void eat(){cout << "Animal -- eat" << endl;}
    // 成员函数move()
    virtual void move(){cout << "Animal -- move" << endl;}
};

/**
 * 定义狗类：Dog
 * 此类公有继承动物类
 * 成员函数：父类中的成员函数
 */
class Dog : public Animal
{
public:
    // 构造函数
    Dog(){cout << "Dog" << endl;}
    // 析构函数
    virtual ~Dog(){cout << "~Dog" << endl;}
    // 成员函数eat()
    virtual void eat(){cout << "Dog -- eat" << endl;}
    // 成员函数move()
    virtual void move(){cout << "Dog -- move" << endl;}
};

int main(void)
{
    // 通过父类对象实例化狗类
    Animal *a = new Dog();
    // 调用成员函数
    a ->eat();
    a ->move();
    // 释放内存
    delete a;
    a = NULL;
    
    return 0;
}

运行结果：

Animal
 Dog 
 Dog -- eat
 Dog -- move
 ~Dog
 ~Animal
  • 因为父类使用虚析构函数。所以释放内存。
  • 因为子类种有父类的同名函数，所以在子类的虚函数表中指向方法的指针被覆盖。
  • 实现了父类对象调用子类方法。
weixin_34387468
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多态(C++)
Handsomewgb的博客
03-13 618
多态概念&作用 多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 静态多态：编译器在编译期间完成，编译器根据函数实参的类型(可能会进行隐式类型转换),可推断出要调用哪个函数
虚函数与纯虚函数区别
yanghaitao的博客
06-17 1367
总结： 1、纯虚函数声明如下： virtual void funtion1()=0; 纯虚函数一定没有定义，纯虚函数用来规范派生类的行为，即接口。包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用。 2、虚函数声明如下：virtual ReturnType FunctionName(Parameter)；虚函数必须实现，如果不实现，编译器将报错，错误提示
9-C++远征之多态篇-学习笔记
weixin_34381666的博客
07-22 157
C++远征之多态篇 本文及代码收录于个人编程笔记(整理中,欢迎Star):https://github.com/mtianyan/Programming-Notebook 面向对象三大特征：封装，继承，多态 多态: 发出一条命令时，不同的对象接收到同样的命令做出的动作不同 多态篇会学习到的目录： 普通虚...
C++-05继承和多态
最新发布
03-11
C++继承和多态的学习笔记
C++程序设计-封装、继承多态应用示例
05-09
在C++编程语言中，封装、继承和多态是面向对象编程（OOP）的三大核心概念。这些特性使得C++能够构建出高效、模块化的软件系统。下面将详细解释这三个概念及其在“C++程序设计-封装、继承多态应用示例”中的体现。 1...
Java ------ 多态作业
04-15
Java ------ 多态作业
行业分类-设备装置-多态计算平台及其构造方法.zip
08-25
3. **资源管理和调度**：在多态计算平台上，有效的资源管理和调度策略至关重要。这包括任务分解、工作负载均衡、能耗管理等方面，目标是在保证性能的同时，降低能耗和提高资源利用率。 4. **并行与分布式计算**：...
第8章-- virtual函数 与多态
07-31
第8章--virtual函数与多态
[ISSUE][PENDING]cocos2d-x ... error C2059: 语法错误:“-”
weixin_33921089的博客
09-15 102
在定义的头文件中并没有使用到任何coco2d-x的东西，提示错误 error C2059: 语法错误:“-” (..\..\src\Xxxx.cpp)error C2143: 语法错误 : 缺少“;”(在“}”的前面) (..\..\src\Xxxx.cpp)error C2238: 意外的标记位于“;”之前 (..\..\src\Xxxx.cpp)error C2575: “updateQua...
C++虚函数(4) - 静态函数能否为虚函数
热门推荐
水草的专栏
05-26 1万+
C++虚函数(4) - 静态函数能否为虚函数
java多态天涯明月笙_天涯明月笙
weixin_34388311的博客
02-27 155
C++远征之多态篇面向对象三大特征：封装，继承，多态多态: 发出一条命令时，不同的对象接收到同样的命令做出的动作不同多态篇会学习到的目录：普通虚函数 & 虚析构函数纯虚函数：抽象类 & 接口类RTTI (运行时类型识别)异常处理概念区分: 隐藏 & 覆盖 | 早绑定与晚绑定虚函数表(核心部分)多态的内容很多，概念也听起来有点变态不过这也是最精彩的部分了。c++ 虚函数什么是...
虚函数和纯虚函数的区别
编程资料大全
05-11 4556
首先：强调一个概念定义一个函数为虚函数，不代表函数为不被实现的函数。 定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。 定义一个函数为纯虚函数，才代表函数没有被实现。 定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。1、简介 假设我们有下面的类层次：class A { public: virtual void foo() { c...
类成员函数模板可以是虚拟的吗？
xfxf996的博客
08-06 944
I have heard that C++ class member function templates can't be virtual. 我听说C ++类成员函数模板不能是虚拟的。 Is th
C++继承类和基类之间成员函数和虚函数调用机制
weixin_30321449的博客
11-22 222
今天去参加百度的面试，遇到一个关于虚函数的机制的问题，我一直认为就是为了让基类指针或引用（指向继承类）能够看到基类的虚函数（当基类的虚函数没有被继承类重写），但是继承类又怎么看到基类的普通成员函数呢？我开始想，好想不可以调用基类的成员函数，因为基类的成员函数不是虚函数，在虚表找不到它，好吧，明天被鄙视了。回到家好好的研究了一下虚函数和成员函数，看看基类的成员函数和虚函数在派生类指针或引用是否可见，...
无规矩不成方圆 - C/C++ 多态
05-23
在 C++ 中，多态是面向对象编程的一种重要概念。它允许我们使用基类的指针或引用来调用派生类的方法，从而实现动态绑定的效果。C++ 中的多态主要分为两种：静态多态和动态多态。 静态多态是指函数重载，它是在编译...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值