C++面向对象笔记（5）：多态篇

最新推荐文章于 2021-11-29 19:50:53 发布
最新推荐文章于 2021-11-29 19:50:53 发布
阅读量591 收藏 3
点赞数 1
分类专栏： 个人笔记 文章标签： C++多态 C++虚函数 C++异常处理 C++接口类 C++抽象类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42533853/article/details/94362840
版权

文章目录

C++多态篇

本章主要的内容：

  1. 普通虚函数、虚析构函数。

  2. 纯虚函数（抽象类、接口类）

  3. RTTI

  4. 异常处理

  5. 隐藏VS覆盖，之间的关系

  6. 早绑定、晚绑定。

  7. 虚函数表。

1.什么是多态

  1. 多态具体到语法中是指，使用父类指针指向子类对象，并可以通过该指针调用子类的函数（方法）。

  2. 产生多态的基础是继承关系，没有继承就没有多态。

  3. 多态的语法核心是virtual关键字，必须使用virtual才能使多个类间建立多态关系。（virtual是可以继承的，父类的函数（方法）写了virtual，子类同名的函数（方法）继承virtual；但是，还是推荐自己手动写上，以起到提示的作用）

  4. 封装、继承、多态是面向对象的三大特性。

1.多态分类-静态多态和动态多态（早绑定和晚绑定）

分为静态多态和动态多态。

1.**静态多态：**也称“早绑定”。

如下所示：

如下的调用方式（函数的重载），程序在编译阶段就知道rect.calcArea()到底要调用哪个函数了，很早的就将函数编译进去了，所以又叫早绑定。

class Rect{
public:
    int calcArea(int width);
    int calcArea(int width, int height);
}

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

2.**动态多态：**也叫“晚绑定”。

对不同的对象，下达相同的指令，导致对象做着不同的操作。

例如：shape父类有Circle和Rect两个子类，利用父类的指针调用Circle和Rect中计算面积的同名函数，那么同名的函数，却能做出不同的动作，这就是动态多态。

动态多态的前提：必须以封装和继承为基础。

3.普通虚函数-实现动态多态（晚绑定）

在父类指针中调用子类的成员函数：

Shape为Circle和Rect父类，3个类都有calcArea()，现在想要分别调用Circle和Rect中的calcArea()。

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

当运行程序时，就会发现实际上调用的都是Shape中的calcArea()，但是实际上我们想要调用的是Circle和Rect中的calcArea()，如果要解决当前的问题，就需要使用动态多态。

实现动态多态：

我们需要使用virtual关键字，使其成为虚函数，步骤如下：

1.在父类声明中，对需要实现动态多态的函数添加virtual：

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

2.在子类声明中，对同名函数中添加virtual：

系统会自动加，但是手动加上能起到提示的作用，还是建议手动添加。

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

3.然后就可以使用本章最开始的代码，对子类中的函数进行调用了。

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

4.虚析构函数-解决动态多态中存在的问题

首先说一下动态多态的问题：内存泄露问题。用上一节的代码来讲解。

导致内存泄露的原因是：

  1. 动态多态的调用如下：

    父类的指针去指向子类对象，Shape *shape1 = new Circle(4.0);；并通过父类指针去操作子类中的虚函数，shape1->calcArea();。

  2. 使用delete手动释放内存时，析构函数的调用：

    当使用delete去销毁对象时，如果delete后面跟着的是父类的指针，那么将只调用父类的析构函数。如果delete后面跟着的是子类的指针，那么将调用子类以及父类的析构函数。

在此表现为，子类的析构函数没有被调用，只调用了父类的析构函数。如果我们子类的构造函数手动申请了内存（用new，申请在堆中），那么这段内存也就自然没有被释放，比如下面这种类的声明：

// Circle类的声明
class Circle : public Shape{
    public ：
        //...
        virtual double calcArea();
    private:
    	//...
    	Coordinate *m_pCenter;// Coordinate类的指针
}

// Circle类的实现-构造函数
Circle::Circle(int x,int y,double r){
    //...
    m_pCenter = new Coordinate(x,y);// 在堆上创建Coordinate类
}
// Circle类的实现-析构函数
Circle::~Circle(){
    delete m_pCenter;// 释放堆中申请的内存
    m_pCenter = nullptr;
}

如上所示，如果没有调用Circle类的析构函数，m_pCenter所指向的类是不会被释放的。

再次强调 - 使用delete释放对象：

当使用delete去销毁对象时，如果delete后面跟着的是父类的指针，那么将只调用父类的析构函数。如果delete后面跟着子类的指针，那么将调用子类和父类的析构函数。

解决动态多态带来的内存释放问题：

要解决这个问题就需要使用虚析构函数，在上一篇笔记有说明以及代码（04继承篇第4章“isA语法“）。

在析构函数上使用virtual修饰即可；需要注意的是，和动态多态中的普通虚函数一样，virtual会被继承，所以在父类的析构函数上加virtual修饰之后，也需要在子类的析构函数上加virtual修饰，起到提示的作用。

虚函数的使用限制：

  1. 只能修饰类中的成员函数。
  2. 不能修饰静态的成员函数。（因为静态成员函数不属于任何一个对象，它是和类同生共死的）
  3. 不能修饰内联函数，如果使用会使计算机忽视inline修饰符。
  4. 构造函数不能成为虚函数。

关于类的构造函数和析构函数调用顺序：

本例中使用了new来在堆上创建Coordinate的内存空间，而堆上的空间是需要我们手动申请和释放的；

所以Coordinate对象析构函数的调用，完全取决于我们什么时候使用delete释放对象，所以Coordinate对象析构函数并不一定在Circle的析构函数之前调用；

例如本例中，就是将Coordinate对象的释放放在Circle的析构函数中，导致Coordinate对象析构函数在Circle的析构函数运行时进行调用。

本章小总结：

  1. 只有虚析构函数，没有虚构造函数。
  2. 虚函数特性可以被继承，当子类中定义的函数与父类中虚函数的声明相同时，该函数也是虚函数。
  3. 虚析构函数是为了避免使用父类指针释放子类对象时造成内存泄露。

5.虚函数的实现原理-多态的实现原理

虚函数的实现：

在本例中，子类Circle没有实现calcArea()这个虚函数，所以直接继承父类的虚函数。

// 父类，声明了calcArea()这个虚函数
class Shape{
public:
    // 虚函数
    virtual double calcArea(){
    }
protected:
    int m_iEdge;
};

// 子类，没有声明calcArea()虚函数，继承父类的虚函数
class Circle : public Shape {
public:
    Circle(double r);
private:
    double m_dR;
}

虚函数表的指针：

在具有虚函数的情况下，实例化一个对象的时候，这个对象的第一块内存当中是一个指针，那么这个指针就是虚函数表的指针。

父类、子类与虚函数表之间的关系：

父类：

[外链图片转存失败(img-s7WRdUvO-1563352606307)(images/muke_C++/010.png)]

vftable_ptr：虚函数表指针，指向虚函数表。

calcArea_ptr：在虚函数表中的函数指针，指向需要调用的函数。

子类：

[外链图片转存失败(img-UycqnOhN-1563352606308)(images/muke_C++/011.png)]

如果对当前的子类添加虚函数的声明：

class Circle : public Shape {
public:
    Circle(double r);
    virtual double calcArea();// 添加了虚函数的声明
private:
    double m_dR;
}

则子类与虚函数表之间的关系变为：

在这里calcArea_ptr这个指针函数指向的地址发生了变化，不再指向与父类相同的calcArea()函数的地址。（覆盖对0x3355的指向，重新指向到0x4B2C上）

[外链图片转存失败(img-LBetAv9r-1563352606309)(images/muke_C++/012.png)]

上面这些就是实现多态的原理了。

6.函数的覆盖与隐藏

函数的隐藏：

在我们还没有学习多态的时候，如果定义了父类和子类，父类和子类出现了重名函数，这个时候就称之为 函数的隐藏。（看第4篇继承篇第3章“继承中同名成员的隐藏”）

// Person为Soldier的父类
int main(){
    Soldier so;
    so.play();			// 调用子类中的play()
    return 0;
}

函数的覆盖：

函数的覆盖特点是使用了虚函数。

如果没有在子类当中定义同名的虚函数，那么在子类虚函数表当中，就会写上父类的相应的那个虚函数的函数入口地址。如果我们在子类当中也定义了重名的虚函数，那么在子类的虚函数表当中，我们就会把原来的父类的虚函数的函数地址，覆盖成子类的虚函数的函数地址，那么这种情况就称值为 函数的覆盖。（看本篇第2章“普通虚函数”）

7.虚析构函数的实现原理

虚析构函数的特点是：

当我们通过父类当中，通过virtual修饰析构函数之后，我们通过父类的指针再去指向子类的对象，然后通过delete接父类指针，就可以释放掉子类对象了。

虚析构函数的理论前提：

执行完子类的析构函数就会执行父类的析构函数。

结合特点和理论前提：

可以看出，实际上虚析构函数的特点就是函数的覆盖带来的。父类的指针指向子类，然后就可以通过delete调用子类和父类的析构函数。

对象的大小：

对象的大小包含类的成员属性、虚函数表的指针大小，不包含成员函数的大小。

8.虚函数小结

  1. 在C++中多态的实现是通过虚函数表实现的。

  2. 当类中仅含有虚析构函数，不含其它虚函数时，不产生虚函数表也会产生虚函数表。

  3. 每个类只有一份虚函数表，所有该类的对象共用同一张虚函数表。

  4. 两张虚函数表中的函数指针可能指向同一个函数。

问：

类普通成员函数怎么调用？

为什么成员数据有内存存放，虚成员函数能通过虚函数指针->虚函数表找到?

普通成员函数至少有函数指针吧,不然怎么找到实现呢？

如果有为什么对象大小只有数据成员的大小？

答：

因为，内存中有程序代码区，堆区，栈区，全局区（静态区），文字常量区。在定义一个类时，它的成员函数，虚构函数，构造函数就被存入程序代码区，供所有对象调用。

在实例化一个类的对象时，并没有拷贝类的函数，仅仅存入了数据成员，因此类的对象中有数据成员，然而当用父类的指针指向子类的对象时，调用同名函数时会调用父类的同名函数，当想要调用子类的同名函数引入了虚函数，

当调用普通成员函数时，计算机可以在代码区识别该函数，无需用函数指针，因而，在对象中只有数据成员的大小。

转自：类普通成员函数怎么调用？

问：

为什么要用父类的指针实例化子类的对象？为什么不直接使用子类的指针实例化子类的对象？

答：

父类A既可以用A本身实例化，也可以用子类B来实例化，一种方法，多种表达方式，所以是多态。

转载自：为什么要用父类的指针实例化子类的对象？

9.纯虚函数

写法：没有函数体，等于0。即，只有函数声明没有函数定义的虚函数。

class Shape{

public:
    // 虚函数
    virtual double calcArea(){
        return 0;
    }
    // 纯虚函数
    virtual double calcPerimeter() = 0;
}

纯虚函数与虚函数表：

[外链图片转存失败(img-pTWRysfZ-1563352606309)(images/muke_C++/013.png)]

纯虚函数的不像普通虚函数那样有函数指针（或者说函数指针没有指向实现的函数，因为实现的函数压根不存在）。

10.抽象类

含有纯虚函数的类叫抽象类。

  1. 不允许抽象类实例化对象。

  2. 抽象类的子类也可能是抽象类。

11.接口类

没有构造函数、析构函数，没有数据成员，只有纯虚函数。

  1. 仅含有纯虚函数的类称为接口类。
  2. 接口类也是抽象类
  3. 接口类不能可以被继承
  4. 不能使用接口类实例化对象接口类中仅有纯虚函数，不能含有其它函数，但可以不能含有数据成员。
  5. 可以使用接口类指针指向其子类对象，并调用子类对象中实现的接口类中纯虚函数。
  6. 一个类可以继承一个接口类，也可以继承多个接口类。
  7. 一个类可以继承接口类的同时也继承非接口类。

接口类和抽象类在构成上的区别：

接口类：只有纯虚函数，不包含其它非纯虚函数。（无其他成员函数、构造函数、析构函数、数据成员）

抽象类：含有纯虚函数，还可以有其他成员函数。（可以含有成员函数、数据成员、构造函数、析构函数）

12.RTTI-运行时内存识别(Run-Time Type Identification)

RTTI中主要会用到dynamic_cast 和typeid。

看一下常见用法：

// 判断当前指针或引用的类型
// 头文件： #include<typeinfo>
if(typeid(*obj) == typeid(Bus)){
}

// 指针类型转换
// Bird是Flyable的子类（必须要有继承关系）
// 并且必须是多态类型（类中含有虚函数）
Flyable *p2 = new Bird();
Bird *b2 = dynamic_cast<Bird *>(p2);

用代码举个例子：

// Flyable，接口类
class Flyable{
    
public:
    virtual void takeoff() = 0;// 起飞，纯虚函数
    virtual void land() = 0;// 降落，纯虚函数
};

// Bird，继承Flyable，，实现了父类的纯虚函数
class Bird : public Flyable{

public:
    void foraging(){......}
    virtual void takeoff(){......}
    virtual void land(){......}
private:
    // ...
};

// Plane，继承Flyable，实现了父类的纯虚函数
class Plane : public Flyable{
    
public:
    void carry(){......}
    virtual void takeoff(){......}
    virtual void land(){......}
}

// 全局函数：
void doSomethine(Flyable *obj){
    
    obj->takeoff();
    
    // 这里要实现如下效果：
    // 如果是Bird，则运行“觅食”
    // 如果是Plane，则运行“运输”
    cout << typeid(*obj).name() << endl;	// 输出类名
    if(typeid(*obj) == typeid(Bird)){		// 判断类的类型（typeid）
        Bird *bird = dynamic_cast<Bird *>(obj);// 转化为子类指针
        bird->foraging();					// 调用子类函数
    }
    
    obj->land();
}

// 调用全局函数，传递地址到指针中
int main() {
    
    Bird b;
    doSomething(&b);
    
    return 0;
}

dynamic_cast 注意事项：

  1. 只能应用于指针和引用的转换。
  2. 要转换的类型中必须包含虚函数。
  3. 转换成功返回子类的地址，失败返回NULL。

typeid 注意事项：

  1. type_id返回一个type_info对象的引用。
  2. 如果想通过基类的指针获得派生类的数据类型，基类必须带有虚函数。
  3. 只能获取对象的实际类型

RTTI小结：

  1. RTTI技术可以通过父类指针识别其所指向对象的真实数据类型

  2. 运行时类型别必须建立在虚函数的基础上，否则无需RTTI技术

  3. 只要存在继承关系就一定可以使用运行时类型识别技术要使用RTTI，必须存在继承关系，继承关系不是RTTI的充分条件，只是必要条件，所以存在继承关系的类不一定可以用RTTI技术。

13.异常处理

常见的异常：

  1. 数组下表越界
  2. 除数为0
  3. 内存不足

异常处理关键字：

try...catch...：在try运行逻辑代码，如果要抛出异常，使用throw，在catch中进行捕获并处理。

throw：抛出异常。（注意：throw之后的代码将不会再运行）

try与catch是一对多的关系，举个例子：

void fun1(){
    
    throw 1;
}


int main(void){
    
    try{
    	fun1();
	}
	catch(int){// 当抛出的异常为int类型
	    //...
	}
	catch(double){// 当抛出的异常为double类型
	    //...
	}
	catch(...){// 这种写法可以捕获所有的异常，用来兜底
	    //...
	}
    
}

如何获取到抛出的异常信息：

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

/**
 * 定义函数division
 * 参数整型dividend、整型divisor
 */
int division(int dividend, int divisor)
{
    if(0 == divisor)
	{
        // 抛出异常，字符串“除数不能为0”
		throw string("除数不能为0");
	}
	else
	{
		return dividend / divisor;
	}
}

int main(void)
{
	int d1 = 10;
	int d2 = 2;
	int r = 0;
	cin >> d1;
	cin >> d2;
    // 使用try...catch...捕获异常
	try{
	    int x = division(d1,d2);
	    cout << "division = " << x << endl;
	}catch(string &errorStr){
	    cout << errorStr << endl;
	}

	return 0;
}

异常处理和多态之间的关系：

可以创建一个Exception的父类，下面有IndexException、MemoryException等子类，然后我们就可以利用多态的特性，用父类捕获各子类，然后做出不同的操作了。

举个例子：

#include <iostream>
using namespace std;

// 父类Exception定义
class Exception{
public:
    // 虚析构函数，用于父类指向子类时，
    // 防止子类的构造函数不被调用，导致的内存泄漏问题
    virtual ~Exception(){}

    // 纯虚函数，在子类中实现
    //virtual void printException() = 0;
	// 虚函数，子类的实现可以将其覆盖
    virtual void printException() {
        cout << "Exception -- printException" << endl;
    }
};

// 两个Exception子类定义
class IndexException : public Exception {
public:
    virtual void printException(){
        cout << "IndexException -- printException" << endl;
    }
};
class MemoryException : public Exception {
public:
    virtual void printException(){
        cout << "MemoryException -- printException" << endl;
    }
};

// 业务处理函数，假如在此函数中发生异常，我们将异常进行抛出
void businessProcessing(){

    // 抛出索引异常
    //throw IndexException();
    // 抛出内存异常
    throw MemoryException();
}

int main() {
	// 对抛出的不同异常，可以做不同的操作（调用相应类中的printException函数）
    try{
        businessProcessing();
    }
    catch(Exception &e){
        e.printException();
    }
    return 0;
}
/*输出：
MemoryException -- printException
或
IndexException -- printException
*/

这里就利用了类的多态 ，这样在业务处理中我们就能用Exception去使用MemoryException，IndexException。

本篇为视频教程笔记，视频如下：

C++远征之多态篇

石呈景
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
僕と若手プログラムとの会話（9）
华 英雄
04-08 1万+
８　Ｈｉｂｅｒｎａｔｅとの連携僕：どうだい。調べものは終わったかい？手：いえ、Ｈｉｂｅｒｎａｔｅをネットで調べていたんですけど、僕の苦手な英語のサイトや本ばかりであきらめようと思ってたんですよ。僕：あきらめるんなんて、君らしくもないね。それに、英語が読めるというのは今のエンジニアにとっては最低限の必須科目だよ。手：相変わらず 厳しいですね~！僕：残念なことだけど、この業界の新しい技術は
2021-08-12c++考试题目
weixin_51516624的博客
08-12 1682
一、选择题（每题3分） 1.关于虚函数，正确的描述是() A 构造函数不能是虚函数 B 析构函数不能是虚函数 C 虚函数可以是友元函数 D 虚函数可以是静态成员函数 2.在32位操作系统g++编译器环境下，下面程序的运行结果为（） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ...
国外的有名嵌入式网站收集
热门推荐
yang57612149的博客
03-01 103万+
转载于http://blog.chinaunix.net/uid-10696433-id-2935848.html 关于嵌入式开发的站点，提供非常多关于嵌入式开发的资料。包括开发公司，技术文档，免费资源等等。版面包括busses & boards,embedded software,dsp,embedded systems,open source,rtos,embedded chips,sy
收藏不看系列！7大免费资源网站，日后再也不求人
cenfeng的博客
08-07 9万+
因为之前俺写过几篇资源安利的文章，导致后台求资源的私信从来没断过…… 唉，谁让我宠粉呢？压箱底的良心安利来啦！ 本文将涵盖影视、音乐、模板、漫画、网盘、小说、合集展开！ 闲话不多侃，废话不多谈，咱们来吃够！ 1、疯狂影视搜索 http://ifkdy.com/ ——超实用的影视搜索引擎 奇了怪了，这类网站竟然没有弹窗和广告，简洁到如此地步，也是神了...
C++基础篇(4)
sinat_32043495的博客
03-26 292
多态：是指相同的对象收到不同的消息或者不同的对象收到相同的消息时会产生不同的动作静态多态（早绑定）：class Rec{ Rec(); recArae(int height); recArae(int height,int width);}int main(){ Rec rec; rec.recArae(10); rec.recAr...
Essential C++ 笔记（5）：基于对象的编程风格（下）
bwqiang的博客
06-05 239
  继上篇的文章《Essential C++ 笔记（4）：基于对象的编程风格（上）》，继续更新Essential C++ 笔记。 7、合作关系必须建立在友谊的基础上   任何class均可以将其他函数或其他类指定为它的朋友（friend）。所谓的friend就具备了和类成员函数相同的访问权限。在类的内部必须是将非成员函数设为朋友。 class Triangular { friend int operator*(const Triangular_iterator &rhs); }; class Tr
面向对象的程序设计-个人复习笔记
10-26
在C++编程语言中，面向对象编程是一种核心概念，它基于类和对象的概念，使得代码更加模块化和易于管理。...通过阅读和理解这些笔记，可以巩固对C++面向对象编程的理解，为解决实际问题打下坚实基础。
c++面向对象设计笔记
06-14
本笔记涵盖了C++面向对象设计的基本概念和技术，包括面向对象程序设计的基本原则、类和对象、继承和多态、运算符重载、C++语言的基本语法元素等。 1.1 主要内容 本节介绍了C++语言的基本概念，包括课程简介、C++...
C++面向对象学习笔记
07-31
C++是一种支持面向对象编程（OOP）的高级编程语言，其面向对象特性包括类、对象、封装、继承和多态。本篇笔记主要探讨了C++程序在内存中的存储方式，即内存分区模型，包括代码区、全局区、栈区和堆区。 1. **内存...
C++圆类的实现
06-27
圆类C++实现，编译，运行通过，大一的水平，交作业时用的 。
C++学习笔记- 面向对象 .md
11-13
内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联函数，this指针，静态成员...
JAVA面向对象基础入门笔记（对比C++）
12-21
本篇文章将对比这两种语言，着重讲解 Java 的面向对象基础知识。 首先，Java 中的“类”是面向对象编程的基础单元，可以视为 C++ 中的“结构体”和“函数”的结合体。类定义了一组属性（也称为字段或成员变量）和...
嵌入式工程师综合笔试题之C++（含部分答案）
qq_43577471的博客
09-23 799
List item 嵌入式工程师综合笔试题之C++ 1、 初始化和赋值的区别是什么？定义和声明的区别是什么？ 赋值操作是在两个已经存在的对象间进行的，而初始化是创建一个新的对象并且初始化来源于另一个存在的对象.初始化是在编译时进行的,而赋值是在函数或程序运行时进行. 定义也是申明,extern声明不是定义,及不分配内存空间. 声明有初始化就被当做定义. 带有{}就是定义,否则就是声明. 除非有extern关键字,否则就是变量的定义. 2、 什么是“引用”？引用和指针的区别？声明和使用“引用”要注意哪..
c++远征之多态篇——虚函数及其实现原理
主要记录嵌入式学习与开发过程。
06-16 638
以下内容源于慕课网的学习整理，如有侵权，请告知删除。  1、多态的定义 简单理解，就是对于同一条命令，不同对象会做出不同的操作。相同对象收到不同消息，或者不同对象收到相同消息时，产生不同的动作。 2、多态的分类 （1）静态多态（早绑定） 如函数重载，在编译阶段，（根据传参情况）就已经知道要执行哪个函数。 （2）动态多态（晚绑定） a、虚函数
31day---C++面试题
jjjstephen的博客
08-14 262
1.有以下程序，程序的输出结果是 0 #include <stdio. h> int fun( int a ) { int b = 0; static int c = 3; a = ( c + +,b + + ); return ( a ); } main( ) { int a = 2,i,k; for( i = 0;i<2;i + + ) k = fun( a + + ); printf("%d\n",k ); }
C++编程入门知识（四）
CJBHbc的博客
11-29 637
29.运算符重载 ①概念：给原有运算符赋予新功能 ②关键字：operator ③++运算符重载需要区分前置++重载和后置++重载。 ④有些运算符必须使用成员函数重载，有些则必须使用友元函数重载。 30.继承 <一> ①被继承的类叫做基类也叫做父类，从其他类继承而来的类叫做派生类也叫做子类。 ②子类中不仅继承了父类中的数据成员，也继承了父类的成员函数。 ...
【C++】多态 - 虚函数/虚析构函数以及虚函数表
onlyongwang的博客
06-09 1214
什么是多态： 指不同对象收到相同消息时或相同对象收到不同消息时产生不同的动作。 这里先说下为什么会用到虚函数： 以下面的程序为例：   这个程序中，Carp是Fish的继承类，而Carp中覆盖了Swim这个方法，在MakeFishSwim这个函数中，要使用Fish类的形参，而你将yourFish这个Carp类的实参传递给了这个函数，让他执行Swim这个函数，这会发生什么，上面的程序运...
思维进化算法优化BP神经网络——非线性函数拟合.rar
最新发布
07-26
神经网络的matlab案例，本案例介绍如下： 技术深度：案例详细介绍了如何使用MATLAB进行深度学习模型的构建、训练和测试。 实际应用：通过具体的图像识别任务，展示模型的实际应用效果，让你直观感受神经网络的强大能力。 代码解析：提供完整的MATLAB代码，并对关键部分进行详细注释，帮助你理解每一步的工作原理。 优化策略：探讨不同的训练策略和参数调整方法，优化模型性能。
C++面向对象编程：多态学习与解析
这篇学习笔记主要涵盖了C++语言中的面向对象编程，特别是多态这一核心概念。C++是一种强大的、通用的编程语言，由比雅尼·斯特劳斯特鲁普博士在1979年开始开发，最初被称为"带有类的C"，最终演变成C++。1998年，C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值