【C++学习】类和对象--多态【待补充】

这篇具有很好参考价值的文章主要介绍了【C++学习】类和对象--多态【待补充】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

多态的基本语法

多态是C++面向对象三大特性之一

静态多态:

        函数重载和运算符重载属于静态多态,复用函数名(函数地址早绑定,编译阶段确定函数地址)

动态多态:

        派生类和虚函数实现运行时多态(函数地址晚绑定,运行阶段确定函数地址)

 案例:

#include<iostream>
using namespace std;
class animal
{
public:
	void speak()
	{
		cout << "animal is speaking" << endl;
	}
	/*改成下面就可以变成小猫说话了,即多态
	virtual void spaek()//虚函数
	{
		cout << "animal is speaking" << endl;
	}
	*/
};
class cat :public animal
{
public:
	void speak()//virtual可写可不写
	{
		cout << "cat is speaking" << endl;
	}
};
void dospeak(animal& animal)//animal &animal=cat;
{//C++中允许父子间的类型转换(无需强制转换)
 //父类的指针或引用可以直接指向子类对象

	animal.speak();

//不管传入什么都会走animal里的speak函数
//因为它是地址早绑定   在编译阶段就确定了函数地址
//如果想让传进来的动物说话  就要让地址晚绑定
}
int main()
{
	cat cat;
	dospeak(cat);
	system("pause");
	return 0;
}

输出:【C++学习】类和对象--多态【待补充】

 但是这里dospeak传入的是cat,我们是想要cat说话

动态多态满足条件

1.有继承关系

2.子类重写父类中的虚函数

(重写:函数返回类型,函数名,参数列表完全相同)

(重载:参数类型不同)

使用:父类的指针或引用  指向子类对象

原理剖析

不管是几级、什么类型,指针都占4个字节

【C++学习】类和对象--多态【待补充】

当子类重写父类的虚函数。

子类中的虚函数  内部  会替换成  子类的虚函数地址。

当父类的指针或者引用指向子类对象的时候,发生多态。

animal& animal=cat;//等号左边编译类型,右边运行类型
//早绑定看编译类型,晚绑定看运行类型

animal.speak();//
## 来自你的消息:
C++多态的原理是什么

## 来自ChatAI的消息:
C++中的多态是指通过基类的指针或引用调用派生类的虚函数,
实现不同对象之间的不同行为。其原理是基于C++中的虚函数和动态绑定机制。

在C++中,通过在基类中声明一个虚函数,并在派生类中重写该虚函数,
可以实现基类指针或引用调用派生类对象时,动态绑定到正确的函数实现。
在运行时,程序会根据对象的类型动态选择调用的函数实现,这一过程称为动态绑定。
这样就可以实现不同的对象之间的不同行为。

C++中的虚函数通过虚函数表(Virtual Table)来实现,每个类中含有一个虚函数表,
表中记录了指向各个虚函数地址的指针。在派生类中重写虚函数时,
会替换掉该函数在虚函数表中原有的指针,从而实现动态绑定。

总的来说,C++多态的原理是基于虚函数和动态绑定机制实现的,
通过基类指针或引用调用派生类对象时,根据对象的类型动态选择调用的函数实现,
实现不同对象之间的不同行为。

## 来自你的消息:
函数地址早绑定和晚绑定是怎么实现的

## 来自ChatAI的消息:
函数地址早绑定和晚绑定是面向对象编程中的两个概念,
早绑定是指在编译时将函数地址绑定到调用点,晚绑定则是在运行时才将函数地址绑定到调用点。

1. 早绑定

在早绑定中,函数地址在编译时就已经确定,
编译器会在函数调用点直接将函数地址嵌入到生成的汇编代码中。
这样可以提高程序的执行效率,因为在运行时不需要动态绑定函数地址,
直接跳转到函数入口就可以执行函数。

例如,C++中非虚函数的调用,就是早绑定的方式。
在调用非虚函数时,编译器已经知道调用的具体函数实现,
因此生成的汇编代码中直接嵌入了函数地址。

2. 晚绑定

在晚绑定中,函数地址要在运行时动态绑定到调用点。
晚绑定主要用于实现面向对象编程中的多态特性。
在多态中,同一个函数可能有多个不同的实现,根据具体的对象类型动态决定调用哪一个实现。

例如,在C++中使用虚函数时,虚函数地址是在运行时根据对象的类型动态绑定的,
这样可以实现动态多态调用。

晚绑定的实现原理是使用虚函数表,每个类的对象都有一个指向自身虚函数表的指针,
虚函数表中存储着类中虚函数的地址,派生类会重写基类的虚函数,
并且在自己的虚函数表中设置指向新函数的地址,这样就可以实现根据对象类型动态绑定函数地址。

总的来说,函数地址的早绑定和晚绑定实现的方式不同,早绑定在编译时就决定函数地址,
而晚绑定需要在运行时根据具体对象类型动态绑定函数地址,主要用于实现多态特性。

案例1-计算器类

多态优点:

              代码组织结构清晰

              可读性强

              利于前期、后期的扩展和维护

对多态的理解:同样是购票,不同的对象有不同的结果。

普通写法

#include<iostream>
#include<string>
using namespace std;

class calculator
{
public:
	int getresult(string op)
	{
		if (op == "+") return m_num1 + m_num2;
		if (op == "-") return m_num1 - m_num2;
		if (op == "*") return m_num1 * m_num2;
	}
	int m_num1;
	int m_num2;
};
void test01()
{
	calculator c;
	c.m_num1 = 10;
	c.m_num2 = 10;
	cout << c.getresult("+") << endl << c.getresult("-") << endl << c.getresult("*") << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

弊端:如果要新增操作  除法  ,就需要修改   getresult  里面的代码。

在真实开发中提倡开闭原则:对扩展进行开放,对修改进行关闭

多态写法

#include<iostream>
#include<string>
using namespace std;
//利用多态实现计算器

class calculator//先实现计算器抽象类
{
public:
	virtual int getresult()
	{
		return 0;
	}
	int m_num1;
	int m_num2;
};
class addcalculator :public calculator
{
public:
	virtual int getresult()
	{
		return m_num1 + m_num2;
	}
};

class subcalculator :public calculator
{
public:
	virtual int getresult()
	{
		return m_num1 - m_num2;
	}
};

class mulcalculator :public calculator
{
public:
	virtual int getresult()
	{
		return m_num1 * m_num2;
	}
};
void test02()
{//多态使用条件
//父类指针或引用指向子类对象

	//加法运算
	calculator* abc = new addcalculator;
	abc->m_num1 = 10;
	abc->m_num2 = 10;
	cout << abc->getresult() << endl;
	
	delete abc;//用完后记得销毁

	//减法运算
	abc = new subcalculator;
	//指针本身是父类指针,释放的是堆区的数据,但是指针本身的类型并没有改变
	abc->m_num1 = 100;
	abc->m_num2 = 120;
	cout << abc->getresult() << endl;
	delete abc;

	//乘法运算
	abc = new mulcalculator;
	//指针本身是父类指针,释放的是堆区的数据,但是指针本身的类型并没有改变
	abc->m_num1 = 10;
	abc->m_num2 = 12;
	cout << abc->getresult() << endl;
}
int main()
{
	test02();
	system("pause");
	return 0;
}

便于修改,可读性强。前后期便于扩展和维护。

C++开发提倡利用多态设计程序架构,因为多态优点很多

纯虚函数和抽象类

在多态中,通常父类中的虚函数的实现是毫无意义的,主要都是调用子类重写的内容。

因此,可以将虚函数改为纯虚函数

纯虚函数语法:virtual  返回值类型   函数名(参数列表)=0;

当类中有了纯虚函数,这个类也称为抽象类

抽象类特点:

        无法实例化对象

        子类必须重写抽象类中的纯虚函数,否则也属于抽象类。

#include<iostream>
using namespace std;
class Base
{
public:
	virtual void func() = 0;//在虚函数的前提下=0,被认为是全虚函数
	//只要有一个纯虚函数,这个类就称为抽象类
	//1.无法实例化对象
	//2.抽象类的子类必须要重写父类中的纯虚函数,否则也属于抽象类
};
class Son :public Base
{
public:
	virtual void func()
	{
		cout << "Son" << endl;
	}
};
void test01()
{
	/*Base b;
	new Base;
	Son s;
	无论是堆区还是栈区,抽象类都无法实例化对象
	*/
	//Son s;//子类必须要重写父类中的纯虚函数,否则无法实例化对象
	Base* base = new Son;
	base->func();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

案例2-制作饮品

#include<iostream>
using namespace std;
class drinking
{
public:
	//煮水
	virtual void boil() = 0;
	//冲泡
	virtual void brew() = 0;
	//倒入杯中
	virtual void pour() = 0;
	//加入辅料
	virtual void add() = 0;
	//制作
	void make()
	{
		boil();
		brew();
		pour();
		add();
	}
};
class coffee:public drinking
{
public:
	//煮水
	virtual void boil()
	{
		cout << "煮农夫山泉" << endl;
	}
	//冲泡
	virtual void brew()
	{
		cout << "冲泡咖啡" << endl;
	}
	//倒入杯中
	virtual void pour()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void add()
	{
		cout << "加入糖和牛奶" << endl;
	}
};
class tea :public drinking
{
public:
	//煮水
	virtual void boil()
	{
		cout << "煮山泉水" << endl;
	}
	//冲泡
	virtual void brew()
	{
		cout << "冲泡茶叶" << endl;
	}
	//倒入杯中
	virtual void pour()
	{
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void add()
	{
		cout << "加入枸杞" << endl;
	}
};
void dowork(drinking *abs)
{
	abs->make();
	delete abs;//做完就释放
}
void test01()
{
	//做咖啡
	dowork(new coffee);
	cout << "---------------------------------------------------" << endl;
	//做茶
	dowork(new tea);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

虚析构和纯虚析构

多态使用时,如果子类中有属性开辟在堆区,那么子类指针在释放时无法调用到子类的析构代码。

解决方法:将父类中的析构函数改为虚析构或纯虚析构。

虚析构与纯虚析构共性:

        可以解决父类指针释放子类的对象

        都需要有具体的函数实现

虚析构和纯虚析构区别:

        如果是纯虚析构,该类属于抽象类,无法实例化对象

虚析构:            virtual     类名(){}

纯虚析构:         virtual  ~类名(){}

总结:

1.虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

2.如果子类中没有堆区数据,可以不写为虚析构或纯虚析构

3.拥有纯虚析构函数的类也属于抽象类

## 来自你的消息:
C++中虚析构和纯虚析构分别是什么,你能详细解释一下吗

## 来自ChatAI的消息:
C++中的虚析构和纯虚析构都用于处理多态的情况下的内存回收问题。

虚析构函数是一个在基类中被声明为虚函数的析构函数。
这意味着,在一个子类对象被删除时,先执行子类的析构函数,再执行父类的析构函数。
这是因为如果只执行子类的析构函数,它的成员变量和指针可能指向父类的对象或其他资源,
这样就可能导致内存泄漏或不可预期的错误。

纯虚析构函数是一个在基类中被声明为纯虚函数的析构函数。
它没有任何实现,只是声明。纯虚析构函数的作用是使一个类成为抽象类,即不能被实例化。
由于一个类的析构函数一定会被调用,所以如果一个类想要成为抽象类,
就必须在其中声明一个纯虚析构函数。

需要注意的是,一个类中只要含有纯虚函数,就不能被实例化,
即不能创建该类的对象,因此纯虚析构函数的存在也起到了一个阻止实例化的作用。
而虚析构函数可以有实现也可以没有,它的主要作用是在多态的情况下确保正确的内存回收。

## 来自你的消息:
为什么基类里的析构函数不能保证内存的释放,加上virtual关键字智慧就可以了?

## 来自ChatAI的消息:
基类中的析构函数没有使用 `virtual` 关键字时,在多态情况下,
如果一个子类对象被删除时,只会调用子类的析构函数而不会调用基类的析构函数,
因为在编译时只知道对象的静态类型,不知道其动态类型,
因此也不知道需要调用哪一个析构函数,这样就无法实现多态时的正确内存回收,
容易导致内存泄漏等问题。

当在基类中加上 `virtual` 关键字使其变为虚析构函数时,
当通过基类的指针或引用删除一个子类对象时,会根据该对象的动态类型来调用正确的析构函数,
实现多态时的正确内存回收。因为使用 `virtual` 关键字会在对象的 Vtable 中为其生成一个虚函数表,包含了类中所有的虚函数和对应的偏移量,使得程序在运行时可以通过动态绑定来确定正确的析构函数。

需要注意的是,只有当类中至少有一个虚函数时,该类才会生成虚函数表,
从而使得类能够使用虚功能,包括虚析构函数。

## 来自你的消息:
虚析构和纯虚析构有什么区别?

## 来自ChatAI的消息:
虚析构函数和纯虚析构函数都可以用于按照规范释放动态分配的内存。
它们主要的区别在于:

1. 纯虚析构函数是一个纯虚函数,没有函数体,即无需提供实现,
但是必须在子类中被重新实现,否则子类也变成了抽象类。
而虚析构函数是一个有实现体的虚函数,通常需要在基类中提供一个默认的实现,
在子类中根据需要进行重写。

2. 如果一个类定义了纯虚析构函数,在该类中不需要为其进行实现,
但在派生类中必须要实现,否则会导致编译错误。而对于虚析构函数,
可以在基类中提供一个默认的实现,子类可以选择继承该实现或者根据需要重新实现。
如果不需要重新实现,则可以在子类中不写任何代码。

3. 纯虚析构函数的主要作用是定义一个基类,使得该基类不能够被实例化。
而虚析构函数的主要作用是定义一个可被实例化的基类,并用于在析构时正确地回收多态对象的内存。

因此,虚析构和纯虚析构主要的应用场景不同。虚析构主要用于处理多态情况下的内存释放问题,
而纯虚析构通常用于定义一个抽象基类,以禁止该类被直接实例化。
#include<iostream>
#include<string>
using namespace std;
class animal
{
public:
	animal()
	{
		cout << "animal的构造函数调用" << endl;
	}
	~animal()
	{
		cout << "animal的析构函数调用" << endl;
	}
	virtual void speak() = 0;
};
class cat:public animal
{
public:
	cat(string name)
	{
		cout << "cat的构造函数调用" << endl;
		m_name = new string(name);
	}
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
	~cat()
	{
		cout << "cat析构函数调用" << endl;
		if (m_name != NULL) delete m_name, m_name = NULL;
	}
	string* m_name;
};
void test01()
{
	animal* animal = new cat("tom");
	animal->speak();
	//父类指针在析构的时候,不会调用子类中析构函数
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

【C++学习】类和对象--多态【待补充】

注意这里出现了问题,少了    cat的析构函数调用。

【C++学习】类和对象--多态【待补充】

 解决:利用虚析构解决父类指针释放子类对象不干净的问题。

#include<iostream>
#include<string>
using namespace std;
class animal
{
public:
	animal()
	{
		cout << "animal的构造函数调用" << endl;
	}
	virtual ~animal()
	{
		cout << "animal的析构函数调用" << endl;
	}
	virtual void speak() = 0;
};
class cat:public animal
{
public:
	cat(string name)
	{
		cout << "cat的构造函数调用" << endl;
		m_name = new string(name);
	}
	virtual void speak()
	{
		cout << "小猫在说话" << endl;
	}
	~cat()
	{
		cout << "cat析构函数调用" << endl;
		if (m_name != NULL) delete m_name, m_name = NULL;
	}
	string* m_name;
};
void test01()
{
	animal* animal = new cat("tom");
	animal->speak();
	//父类指针在析构的时候,不会调用子类中析构函数
	//导致子类如果有堆区属性,就会出现内存泄露情况
	//解决方法 把析构改为虚析构
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

 纯虚析构函数

#include<iostream>
#include<string>
using namespace std;
class animal
{
public:
	animal()
	{
		cout << "animal的构造函数调用" << endl;
	}
	/*virtual ~animal()
	{
		cout << "animal的析构函数调用" << endl;
	}*/
	virtual ~animal() = 0;
	//纯虚析构 需要声明也需要实现
	//有了纯虚析构,这个类也属于抽象类,无法实例化对象

	virtual void speak() = 0;
};
animal::~animal()
{
	cout << "animal的纯虚析构函数调用" << endl;
}
class cat:public animal
{
public:
	cat(string name)
	{
		cout << "cat的构造函数调用" << endl;
		m_name = new string(name);
	}
	virtual void speak()
	{
		cout << *m_name<<"小猫在说话" << endl;
	}
	~cat()
	{
		cout << "cat析构函数调用" << endl;
		if (m_name != NULL) delete m_name, m_name = NULL;
	}
	string* m_name;
};
void test01()
{
	animal* animal = new cat("tom");
	animal->speak();
	//父类指针在析构的时候,不会调用子类中析构函数
	//导致子类如果有堆区属性,就会出现内存泄露情况
	//解决方法 把析构改为虚析构
	delete animal;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

案例3:电脑组装

电脑主要组成部件为CPU(用于计算),显卡(用于显示),内存条(用于存储)

将每个零件封装成抽象基类,并且提供不同的厂商生产不同的零件

创建电脑类提供让电脑工作的函数,并且调用每个零件工作的接口

测试时组装三台不同的电脑进行工作。

懒得敲了,这里参考了:C++多态案例:电脑组装_wangpailiulanqi8的博客-CSDN博客文章来源地址https://www.toymoban.com/news/detail-433200.html

#include<iostream>
#include<string>
using namespace std;

 
//抽象零件类
class CPU 
{
public:
	virtual void Calculator() = 0; 
 
};
 
class VideoCard //显卡
{
public:
	virtual void Display() = 0;
 
};
 
class MemoryBank
{
public:
	virtual void Storage() = 0;
 
};
 
 
//电脑类 :需要调用各个零件的接口
class Computer
{
public:
	//接收指针
	Computer(CPU* cpu, VideoCard* video, MemoryBank* memory)
	{
		m_cpu = cpu;
		m_video = video;
		m_memory = memory;
	}
 
	//使用接口指针,提供工作的函数
	void Work()
	{
		m_cpu->Calculator();
		m_video->Display();
		m_memory->Storage();
	}
 
	//释放指针
	~Computer()
	{
		cout << "computer 析构函数" << endl<<endl;
		if (m_cpu != NULL)
		{
			delete m_cpu;
			m_cpu = NULL;
		}
		if (m_video != NULL)
		{
			delete m_video;
			m_video = NULL;
		}
		if (m_memory != NULL)
		{
			delete m_memory;
			m_memory = NULL;
		}
	}
 
private:
	CPU* m_cpu;
	VideoCard* m_video;
	MemoryBank* m_memory;
 
};
 
//零件的子类
//1、Intel厂商
class IntelCPU :public CPU
{
public:
	void Calculator()
	{
		cout << "Intel的CPU在计算" << endl;
	}
};
 
 
class IntelVideoCard :public VideoCard
{
public:
	void Display()
	{
		cout << "Intel的显卡在显示" << endl;
	}
};
 
class IntelMemoryBank :public MemoryBank
{
public:
	void Storage()
	{
		cout << "Intel的内存在存储" << endl;
	}
};
 
 
//2、Lenovo厂商
class LenovoCPU :public CPU
{
public:
	void Calculator()
	{
		cout << "Lenovo的CPU在计算" << endl;
	}
};
 
 
class LenovoVideoCard :public VideoCard
{
public:
	void Display()
	{
		cout << "Lenovo的显卡在显示" << endl;
	}
};
 
class LenovoMemoryBank :public MemoryBank
{
public:
	void Storage()
	{
		cout << "Lenovo的内存在存储" << endl;
	}
};
 
 
 
 
 
//测试函数
void test01()
{
	//第一台电脑的零件
	CPU* cpu01 = new IntelCPU;
	VideoCard* video01 = new IntelVideoCard;
	MemoryBank* memory01 = new IntelMemoryBank;
 
	//创建第一台电脑
	//使用new创建对象,必须准备一个指针来接收
	Computer *computer01 = new Computer(cpu01, video01, memory01);
	computer01->Work();
	delete computer01;
 
 
	//创建第二台电脑
	Computer* computer02 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemoryBank);
	computer02->Work();
	delete computer02;
 
 
	//创建第三台电脑
	Computer* computer03 = new Computer(new LenovoCPU, new IntelVideoCard, new IntelMemoryBank);
	computer03->Work();
	delete computer03;
 
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}

到了这里,关于【C++学习】类和对象--多态【待补充】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • C++核心编程—类和对象,类的三大特性——封装、继承、多态

    纵有疾风起,人生不言弃。本文篇幅较长,如有错误请不吝赐教,感谢支持。 ①什么是对象? 生活中有各种各样的 事物 ,如人、动物、植物等在C++中将这些称为对象。 对象多种多样, 各种对象的属性也不相同 。 例如狗的品种,毛色,年龄等 各个对象都有自己的行为 ,例

    2024年02月07日
    浏览(64)
  • 【C++精华铺】6.C++类和对象(下)类与对象的知识补充及编译器优化

    目录 1. 再谈构造 1.1 成员变量的初始化(初始化列表) 1.2 初始化列表的行为 1.3 explicit  2. 类中的static成员 2.1 静态成员变量 2.2 静态成员函数 3. 友元 3.1 友元函数 3.1 友元类 4. 内部类  5. 匿名对象  6. 对象拷贝时候的编译器优化           为什么还要去看初始化的问

    2024年02月13日
    浏览(41)
  • C++关于类和对象的基础语法

    目录 前言: 1.OO语言 2.类的定义 3.类的访问限定符与封装的引入 4.类的实例化 5.this指针(很重要) 6.this空指针问题 总结: 类的访问限定符与this指针很重要,在后面会一直用,下一章将会介绍六大默认成员函数。 1.OO语言 谈到类,就离不开对象,而像我们的c++,Java也

    2024年03月23日
    浏览(41)
  • C++类和对象-多态->案例1计算器类、案例2制作饮品、案例3电脑组装需求分析和电脑组装具体实现

    #includeiostream using namespace std; #includestring //分别利用普通写法和多态技术实现计算器 //普通写法 class Calculator { public:     int getResult(string oper)     {         if (oper == \\\"+\\\") {             return m_Num1 + m_Num2;         }         else if (oper == \\\"-\\\") {             return m_Num

    2024年02月20日
    浏览(43)
  • c++学习——类和对象

    类是自定义数据类型,是C语言的结构体进化而成的 对象是类实例化出的,用数据类型定义一个变量 C和C++中struct区别: C语言struct只有变量 C++语言struct既有变量,也有函数 1、为什么要有封装? 封装是把属性(变量)和方法(函数)封装到类内,然后给这些数据赋予权限,防

    2024年02月07日
    浏览(39)
  • 【C++学习】类和对象(上)

    前言: 由于之前电脑“嗝屁”了,导致这之前一直没有更新博客,今天才拿到电脑,在这里说声抱歉。接下来就进入今天的学习,在之前我们已经对【C++】进行了初步的认识,有了之前的知识铺垫,今天我们将来带领大家学习我们【C++】中的一个重要知识,即“ 类和对象 ”

    2023年04月10日
    浏览(33)
  • C++学习:类和对象(上)

    这是C++这样的面向对象的语言具有的特性,相较于C语言来说,更加方便的去编写代码,调用代码。 当需要大量重复的调用同一个函数的时候,我们每创建一个函数,就会建立一个栈帧,这样对于空间来讲不友好,C语言中有宏函数这样的函数,来解决这一问题,下面是宏函数

    2023年04月23日
    浏览(36)
  • C++学习之路(C++初阶)——类和对象(上)

    ✨✨欢迎来到T_X_Parallel的博客!!       🛰️博客主页:T_X_Parallel       🛰️专栏 : C++初阶       🛰️欢迎关注:👍点赞🙌收藏✍️留言       🛰️友友们的支持是本博主更新的动力   本博客主要为学习C++类和对象内容做准备,开头补充

    2024年02月07日
    浏览(58)
  • 【javaSE】内部类(来自类和对象的补充)

    hellohello~,大家好💕💕,这里是E绵绵呀✋✋ ,如果觉得这篇文章还不错的话还请点赞❤️❤️收藏💞 💞 关注💥💥,如果发现这篇文章有问题的话,欢迎各位评论留言指正,大家一起加油!一起chin up!👍👍  💥 个人主页 :E绵绵的博客 💥 所属专栏: JAVASE题目练习

    2024年04月27日
    浏览(31)
  • Python-面向对象:面向对象、成员方法 、类和对象、构造方法、魔术方法、封装、继承、类型注解、多态(抽象类(接口))

    当前版本号[20230806]。 版本 修改说明 20230806 初版 生活中数据的组织 学校开学,要求学生填写自己的基础信息,一人发一张白纸,让学生自己填, 易出现内容混乱 但当改为登记表,打印出来让学生自行填写, 就会整洁明了 程序中数据的组织 在程序中简单使用变量来记录学

    2024年02月14日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包