关于继承和多态

最新推荐文章于 2024-05-13 21:32:22 发布
最新推荐文章于 2024-05-13 21:32:22 发布
阅读量370 收藏 9
点赞数 8
分类专栏： C++ 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaoyuelon/article/details/135988137
版权 
/*
1.继承的本质和原理
继承的本质：a.代码的复用
类与类之间的关系
组合：a part of ... ...一部分的关系
继承：a kind of ... ...一种的关系

继承方式	基类的访问限定	派生类的访问限定	（main）外部的访问限定
public
			public			public					Y		
			protected		protected				N
			private			不可见					N
protected（基类的成员的访问限定，在派生类里面是不可能超过继承方式的）
			public			protected				N
			protected		protected				N
			private			不可见					N
private
			public			private					N
			protected		private					N
			private			不可见					N

总结：
1.外部只能访问对象public的成员，protected和private的成员无法直接访问
2.在继承结构中，派生类从基类可以继承过来private的成员，但是派生类却无法直接访问
3.protected和private的区别？在基类中定义的成员，想被派生类访问，但是不想被外部访问，
那么在基类中，把相关成员定义成protected保护的；如果派生类和外部都不打算访问，那么
在基类中，就把相关成员定义成private私有的。

默认的继承方式：
要看派生类是用class定义的，还是struct定义的？
class定义派生类，默认继承方式就是private私有的
struct定义派生类，默认继承方式就是public
*/

class A
{
public:
	int ma;
protected:
	int mb;
private:
	int mc; //自己或者友元能访问私有的成员
};

//继承 A基类/父类  B派生类/子类
class B : public A 
{
public:
	int md;
protected:
	int me;
private:
	int mf;
};

/*
1.派生类从继承可以继承来所有的成员（变量和方法），除过构造函数和析构函数
派生类怎么初始化从基类继承来的成员变量呢？
解答：通过调用基类相应的构造函数来初始化

派生类的构造函数和析构函数，负责初始化和清理派生类部分
派生类从基类继承来的成员，的初始化和清理由谁来负责呢？是由基类的构造和析构函数来负责

》》》派生类对象构造和析构的过程是：
1.派生类调用基类的构造函数，初始化从基类继承来的成员
2.调用派生类自己的构造函数，初始化派生类自己特有的成员
....派生类对象的作用域到期了
3.调用派生类的析构函数，释放派生类成员可能占用的外部资源（堆内存，文件）
4.调用基类的析构函数，释放派生类内存中，从基类继承来的成员可能占用的外部资源（堆内存，文件）
*/
class Base
{
public:
	Base(int data) : ma(data) { cout << "Base()" << endl; }
	~Base() { cout << "~Base()" << endl; }
protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data) 
		: Base(data), mb(data) // ma(data)
	{
		cout << "Derive()" << endl;
	}
	~Derive()
	{
		cout << "~Derive()" << endl;
	}
private:
	int mb;
};

int main()
{
	Derive d(20);
	return 0;
}

/*
重载、隐藏、覆盖
1.重载关系
	一组函数要重载，必须处在同一个作用域当中；而且函数名字相同，参数列表不同
2.隐藏（作用域的隐藏）的关系
	在继承结构当中，派生类的同名成员，把基类的同名成员给隐藏掉了
*/
class Base
{
public:
	Base(int data = 10) :ma(data) {}
	void show() {
		cout << "Base::show()" << endl;
	}
	void show(int) {
		cout << "Base::show(int)" << endl;
	}
protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data = 20) : Base(data), mb(data) {}
	void show() {
		cout << "Derive::show()" << endl;
	}
private:
	int mb;
};

int main()
{
	Derive d;
	d.show();
	d.Base::show();
	d.Base::show(10);

	return 0;

/*
重载、隐藏、覆盖
1.重载关系
	一组函数要重载，必须处在同一个作用域当中；而且函数名字相同，参数列表不同
2.隐藏（作用域的隐藏）的关系
	在继承结构当中，派生类的同名成员，把基类的同名成员给隐藏掉了


1.把继承结构，也说成从上（基类）到下（派生类）的结构
2.
基类对象 -> 派生类对象
派生类对象 -> 基类对象

基类指针（引用）-> 派生类对象
派生类指针（引用）-> 基类对象

//在继承结构中，进行上下的类型转换，默认只支持从下到上的类型的转换 OK

*/
class Base
{
public:
	Base(int data = 10) :ma(data) {}
	void show() {
		cout << "Base::show()" << endl;
	}
	void show(int) {
		cout << "Base::show(int)" << endl;
	}
protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data = 20) : Base(data), mb(data) {}
	void show() {
		cout << "Derive::show()" << endl;
	}
private:
	int mb;
};

int main()
{
	Base b(10);
	Derive d(20);

	//基类对象b <- 派生类对象d 类型从下到上的转换 Y
	b = d;

	//派生类对象d <- 基类对象b 类型从上到下的转换 N
	//d = b; //不可以

	//基类指针（引用）<- 派生类对象 类型从下到上的转换 Y
	Base *pb = &d;
	pb->show();
	((Derive*)pb)->show();
	pb->show(10);

	//派生类指针(引用) <- 基类对象 类型从上到下的转换 N
	//Derive *pb = &b;
	Derive *pd = (Derive*)&b; //不安全，涉及了内存的非法访问
	pd->show();
}

class Base
{
public:
	Base(int data = 10) : ma(data) {}
	void show() { cout << "Base::show()" << endl; }
	void show(int) { cout << "Base::show(int)" << endl; }

protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data = 20) : Base(data), mb(data) {}
	void show() { cout << "Derive::show()" << endl; }
private:
	int mb;
};

int main()
{
	Derive d(50);
	Base *pb = &d;
	//静态（编译时期）的绑定（函数的调用）call Base::show
	pb->show();
	//静态绑定call Base::show
	pb->show(10);

	cout << sizeof(Base) << endl;//4
	cout << sizeof(Derive) << endl;//8

	cout << typeid(pb).name() << endl; //class Base*
	cout << typeid(*pb).name() << endl; //class Base

	return 0;
}

/*
虚函数，静态绑定和动态绑定

覆盖：
基类和派生类的方法，返回值，函数名以及参数列表都相同，而且基类的方法是虚函数
那么派生类的方法就自动处理成虚函数，它们之间成为覆盖关系

一个类添加了虚函数，对这个类有什么影响
总结一：
一个类里面定义了虚函数，那么编译阶段，编译器给这个类类型产生一个唯一的vftable虚函数表，
虚函数表中主要存储的内容就是RTTI指针和虚函数的地址。当程序运行时，每一张虚函数表都会
加载到内存的.rodata区

总结二：
一个类里面定义了虚函数，那么这个类定义的对象，其运行时，内存中开始部分，多存储一个vfptr虚函数
指针，指向相应类型的虚函数表vftable。一个类型定义的n个对象，他们的vfptr指向的都是同一张虚函数表

总结三：
一个类里面虚函数的个数，不影响对象内存大小（vfptr）,影响的是虚函数表的大小
*/
class Base
{
public:
	Base(int data = 10) : ma(data) {}
	//
	virtual void show() { cout << "Base::show()" << endl; }
	virtual void show(int) { cout << "Base::show(int)" << endl; }

protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data = 20) : Base(data), mb(data) {}
	/*
	总结四：
	如果派生类中的方法，和基类继承来的某个方法，返回值、函数名、参数列表都相同，
	而且基类的方法是virtual虚函数，那么派生类的这个方法，自动处理成虚函数
	*/
	void show() { cout << "Derive::show()" << endl; }
private:
	int mb;
};

int main()
{
	Derive d(50);
	Base *pb = &d;

	/*
	pb->Base Base::show 如果发现show是普通函数，就进行静态绑定 call Base::show
	pb->Base Base::show 如果发现show是虚函数，就进行动态绑定
	mov eax, dword ptr[pb]
	mov ecx, dword ptr[eax]
	call ecx (虚函数的地址) 动态（运行时期）绑定（函数的调用）
	*/

	//静态（编译时期）的绑定（函数的调用）call Base::show
	pb->show();
	//静态绑定call Base::show
	pb->show(10);

	cout << sizeof(Base) << endl;//4 8（多了虚函数指针）
	cout << sizeof(Derive) << endl;//8 12

	cout << typeid(pb).name() << endl; //class Base*
	/*
	pb的类型：Base -> 有没有虚函数
	如果Base没有虚函数，*pb识别的就是编译时期的类型 *pb <=> 类型
	如果Base有虚函数，*pb识别的就是运行时期的类型 RTTI类型
	*/
	cout << typeid(*pb).name() << endl; //class Base class Derive

	/*
	Base的两个show函数都是普通的函数
	Base::show()
	Base::show(int)
	4
	8
	class Base *
	class Base
	*/

	/*
	给Base的两个show方法定义成virtual虚函数了
	Derive::show()
	Base::show(int)
	8
	12
	class Base*
	class Derive
	*/

	return 0;
}

/*
问题一：哪些函数不能实现为虚函数

虚函数依赖：
1.虚函数能产生地址，存储在vftable当中
2.对象必须存在（vfptr -> vftable -> 虚函数地址）

构造函数
1.virtual + 构造函数 NO!
2.构造函数中（调用的任何函数，都是静态绑定的）调用虚函数，也不会发生静态绑定
派生类对象构造过程 1.先调用的是基类的构造函数 2.才调用派生类的构造函数

static静态成员方法 NO! virtual + static
问题二：虚析构函数 析构函数调用的时候，对象是存在的
*/
class Base
{
public:
	Base(int data) :ma(data) 
	{
		cout << "Base()" << endl;
	}
	~Base()
	{
		cout << "~Base()" << endl;
	}
	void show() {
		cout << "call Base::show()" << endl;
	}
protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data)
		: Base(data), mb(data) 
	{
		cout << "Derive()" << endl;
	}
	~Derive()
	{
		cout << "~Derive()" << endl;
	}
private:
	int mb;
};


int main()
{
	Base *pb = new Derive(10);
	pb->show();
	delete pb; //派生类的析构函数没有被调用到
	/*
	pb->Base Base::~Base 对于析构函数的调用，就是静态绑定
	*/
	return 0;
}

class Base
{
public:
	Base(int data) :ma(data) 
	{
		cout << "Base()" << endl;
	}
	//虚析构函数
	virtual ~Base()
	{
		cout << "~Base()" << endl;
	}
	virtual void show() {
		cout << "call Base::show()" << endl;
	}
protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data)
		: Base(data), mb(data) 
	{
		cout << "Derive()" << endl;
	}
	//基类的析构函数是virtual虚函数，那么派生类的析构函数自动成为虚函数
	~Derive()
	{
		cout << "~Derive()" << endl;
	}
private:
	int mb;
};


int main()
{
	Base *pb = new Derive(10);
	pb->show();
	delete pb; 
	/*
	pb->Base virtual Base::~Base 对于析构函数的调用，就是动态绑定
	*/
	return 0;
}

/*
问题一：哪些函数不能实现为虚函数

虚函数依赖：
1.虚函数能产生地址，存储在vftable当中
2.对象必须存在（vfptr -> vftable -> 虚函数地址）

构造函数
1.virtual + 构造函数 NO!
2.构造函数中（调用的任何函数，都是静态绑定的）调用虚函数，也不会发生静态绑定
派生类对象构造过程 1.先调用的是基类的构造函数 2.才调用派生类的构造函数

static静态成员方法 NO! virtual + static
问题二：虚析构函数 析构函数调用的时候，对象是存在的
什么时候把基类的析构函数必须实现成虚函数？
基类的指针（引用）指向堆（堆、堆、堆）上new出来的派生类对象的时候，delete pb（基类的指针）
，它调用析构函数的时候，必须发生动态绑定，否则会导致派生类的析构函数无法调用

Derive d(50);
Base *pb = &d;
栈上的对象会自动正确释放内存
*/
class Base
{
public:
	Base(int data) :ma(data) 
	{
		cout << "Base()" << endl;
	}
	//虚析构函数
	virtual ~Base()
	{
		cout << "~Base()" << endl;
	}
	virtual void show() {
		cout << "call Base::show()" << endl;
	}
protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data)
		: Base(data), mb(data) 
	{
		cout << "Derive()" << endl;
	}
	//基类的析构函数是virtual虚函数，那么派生类的析构函数自动成为虚函数
	~Derive()
	{
		cout << "~Derive()" << endl;
	}
private:
	int mb;
};


int main()
{
	Base *pb = new Derive(10);
	pb->show();
	delete pb; 

	Derive d(50);
	Base *pb = &d;

	//delete pb;
	/*
	pb->Base virtual Base::~Base 对于析构函数的调用，就是动态绑定
	*/
	return 0;
}

/*
虚函数和动态绑定	问题：是不是虚函数的调用一定就是动态绑定？肯定不是
在类的构造函数当中，调用虚函数，也是静态绑定（构造函数中调用其他函数（虚），不会发生动态绑定）
如果不是通过指针或者引用变量来调用虚函数，那就是静态绑定
*/
class Base
{
public:
	Base(int data = 0) :ma(data) {}
	virtual void show() { cout << "Base::show()" << endl; }
protected:
	int ma;
};

class Derive : public Base
{
public:
	Derive(int data = 0) : Base(data), mb(data) {}
	void show() { cout << "Derive::show()" << endl; }
private:
	int mb;
};

int main()
{
	Base b;
	Derive d;

	//静态绑定 用对象本身调用虚函数，是静态绑定
	b.show(); //虚函数 call Base::show
	d.show(); //虚函数 call Derive::show

	//动态绑定（必须由指针调用虚函数）
	Base *pb1 = &b;
	pb1->show();
	Base *pb2 = &d;
	pb2->show();

	//动态绑定（必须由引用变量调用虚函数）
	Base &rb1 = b;
	rb1.show();
	Base &rb2 = d;
	rb2.show();

	//动态绑定（虚函数通过指针或引用变量调用，才发生动态绑定）
	Derive *pd1 = &d;
	pd1->show();
	Derive &rd1 = d;
	rd1.show();

	//Derive *pd2 = &b; //不行
	return 0;
}

/*
抽象类和普通类有什么区别？
一般把什么类设计成抽象类？
//动物的基类 泛指 类->抽象一个实体的类型

定义Animal的初衷，并不是让Animal抽象某个实体的类型
1.string _name; 让所有的动物实体类通过继承Animal直接复用该属性
2.给所有的派生类保留统一的覆盖/重写接口

拥有纯虚函数的类，叫做抽象类
抽象类不能再实例化对象了，但是可以定义指针和引用变量

*/

//汽车的基类
class Car
{
public:
	Car(string name, double oil) 
		: _name(name)
		, _oil(oil) 
	{

	}
	//获取汽车剩余油量还能跑的公里数
	double getLeftMiles()
	{
		return _oil * getMilesPerGallon();
	}
	string getName() const { return _name; }
protected:
	string _name;
	double _oil;
	virtual double getMilesPerGallon() = 0; //纯虚函数
};

class Bnze : public Car
{
public:
	Bnze(string name, double oil) : Car(name, oil) {}
	double getMilesPerGallon() { return 20.0; }
};

class Audi : public Car
{
public:
	Audi(string name, double oil) : Car(name, oil) {}
	double getMilesPerGallon() { return 18.0; }
};

class BMW : public Car
{
public:
	BMW(string name, double oil) : Car(name, oil) {}
	double getMilesPerGallon() { return 19.0; }
};

//给外部提供一个统一的获取汽车剩余路程数的API
void showCarLeftMiles(Car &car)
{
	cout <<  car.getName() << ":" << car.getLeftMiles() << endl;
}

int main()
{
	Bnze b1("奔驰", 20.0);
	Audi a("奥迪", 20.0);
	BMW b2("宝马", 20.0);

	showCarLeftMiles(b1);
	showCarLeftMiles(a);
	showCarLeftMiles(b2);

	return 0;
}

/*
如何解释多态？
静态（编译时期）的多态：函数重载、模板（函数模板和类模板）
bool compare(int, int){}
bool compare(double, double){}

compare(10, 20); call compare_int_int 在编译阶段就确定好调用的函数版本
compare(10.5, 20.5); call compare_double_double 在编译阶段就确定好调用的函数版本

template<typename T>
bool compare(T a, T b) {}

compare<int>(10, 20); => int实例化一个 compare<int>
compare(10.5, 20.5); => double实例化一个compare<double>

动态（运行时期）的多态：
在继承结构中，基类指针（引用）指向派生类对象，通过该指针（引用）调用同名覆盖方法（虚函数）
，基类指针指向哪个派生类对象，就会调用哪个派生类对象的同名覆盖方法，称为多态

多态底层是通过动态绑定来实现的，pbase-》访问谁的vfptr-》继续访问谁的vftable->
									->当然调用的是对应的派生类对象的方法了

继承的好处是什么？
1.可以做代码的复用
2.在基类中给所有派生类提供统一的虚函数接口，让派生类进行重写，然后就可以使用多态了

*/
高二的笔记
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
关于继承和多态的简单练习
08-16
关于继承和多态的简单练习，今天写了个多态的例子练了练手，希望可以对大家有所帮助吧。
C#基础继承和多态详解
09-05
C#基础继承和多态详解，需要的朋友可以参考一下
Python学习之-继承和多态
Summer的博客
04-02 1772
什么是继承？什么是多态？面向对象的三大特性：封装：根据 职责 将属性和方法封装到一个抽象类中继承： 实现代码的重用，相同的代码不需要重复的编写多态： 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度继承继承是一种机制，它使得一个类（称为子类或派生类）能够继承另一个类（称为父类或基类）的属性和行为（方法）。子类除了可以继承父类的功能外，还可以添加新的功能或重写某些功能。单继承: 当一个类仅继承自一个父类时。多继承: 当一个类继承自多个父类时。
C++ 封装、继承和多态
SimpleForest的博客
07-08 1147
多态指的是同一个函数名可以调用不同类型的函数，从而实现不同对象之间的差异性行为。静态多态是通过函数重载和运算符重载来实现的，而动态多态则是通过虚函数来实现的。多态的目的是实现代码的灵活性和可扩展性，使得程序可以更好地适应不同的应用场景。封装是指的是将数据和操作数据的方法封装在类中，使得数据和方法不能被外部直接访问，只能通过类的公共接口进行访问和修改。封装的目的是实现代码模块化和信息隐藏，提高代码的可维护性和可重用性。继承是指的是一个类（子类）通过继承另一个类（父类）的属性和方法，从而实现代码的扩展。
继承与多态
Lucky_mzc的博客
01-05 9745
一.概述 面向对象程序设计的三大原则是封装性，继承性和多态性。继承性是子类自动共享父类的数据和方法的机制，它是由类的派生功能体现的。继承具有传递性，使得一个类可以继承另一个类的属性和方法，这样通过抽象出共同的属性和方法组件新的类，便于代码的重用。而多态是指不同类型的对象接收相同的消息时产生不同的行为，这里的消息主要是对类成员函数的调用，而不同的行为是指类成员函数的不同实现。当对象接收到发送给它的消息时，根据该对象所属的类，动态选用在该类中定义的实现算法。 二.继承 2.1 继承的概述 ...
继承和多态
weixin_58867976的博客
04-23 3199
目录 一、继承的概念和定义 二、基类和派生类对象赋值转换 ​​​​​​​一、继承的概念和定义 继承概念：继承是类设计层次的复用 派生类(子类)：继承使代码复用，在保持原有类特性的基础上进行扩展，增加功能，这样一个新的类，就是派生类 基类(父类)：被继承的类就是基类 继承定义 例如：人和学生，学生具有人的特征同时，还具备学生这个身份特有的一些特征，人可称为基类，学生则是对应的派生类 继承方式 公有继承，保护继承，以及私有继承 派生类中有基类继承的成员类型(是公有是保护还是私有) ..
C++ 继承和多态
凡事都是靠练习
08-17 2030
讲解继承和多态，多态的实现原理
封装 继承和多态
weixin_48121041的博客
01-28 4369
封装继承和多态 封装 我们在设计程序时，讲究六个字，高内聚，低耦合 封装就是我们对数据进行隐藏，多用于来封装属性，封装方法较少。 记住封装的核心，就是私有（private） 令属性为私有后我们调用不了类里面的属性，所以我们设置一些get方法和set方法来操作私有的属性 get方法，set方法 public int getAge(){ return age; } public void setAge(int age){ this.age = age; } 具体代码应用 设置一个学生类，令其定义的属
【Java】继承和多态
qq_74455045的博客
04-30 1445
关键字super；关键字protected；关键字final；组合；小练习：三者乘积；重写override；向上转型与向下转型；运行时绑定；多态
继承和多态的详解
weixin_55079859的博客
06-22 1903
继承和多态的详解
python的继承和多态
weixin_52599204的博客
08-05 2910
多态指的是一类实物有多种形态，定义 多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果；多态依赖继承子类方法必须要重写父类方法。首先定义一个父类，其可能拥有多个子类对象，当我们调用一个公共方法时，传递的对象不同，则返回的结果不同。好处，调用灵活，有了多台，可以更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化。、不同对象访问相同方法，返回不同结果 就是多态代码实现。多态可以基于继承，也可以不基于继承。...
封装、继承和多态
crazy_xieyi的博客
08-07 2084
封装就是对类内部的实现细节进行隐藏，然后对类外提供公开的接口。继承其实是父类对子类的共性的抽取， 实现代码的复用。一个引用调用同一个方法，因为这个引用 引用的对象不一样，导致调用这个方法，所表现出来的行为不一样。这种思想就叫做多态。 ...
Python类继承和多态原理解析
12-20
这篇文章主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 现在属于是老年人的脑子，东西写着写着就忘了，东西记着记着就...
C#第六章 初始继承和多态.pdf
09-04
C#第六章 初始继承和多态.pdfC#第六章 初始继承和多态.pdfC#第六章 初始继承和多态.pdf C#第六章 初始继承和多态.pdfC#第六章 初始继承和多态.pdf
Java 7大排序
m0_74270127的博客
05-10 812
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
【算法】NOIP2003神经网络
最新发布
littlegengjie的博客
05-13 588
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，Ui是阈值，可视为神经元的一个内在参数。然后根据拓扑排序一次遍历该图的所有点（例如便利到点1，会遍历所有以点1位直接前驱的点），遍历点1之后，3、4、5的状态均为1，遍历点2之后3、4、5均为2，将所有输出点的状态减去阈值，就为最终状态。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。
1080：余数相同问题
如果没有特别说明，c++都是基于GCC-4.9.2运行的
05-11 376
【代码】：1080：余数相同问题
找第二大的数（分治法）
2201_75525567的博客
05-11 300
这段代码通过递归的方式，将数组分为两半，并分别找出左半部分和右半部分的两个最大数，然后比较这四个数的大小，得到第二大的数。这段代码是用来找出数组中第二大的数的。
python封装继承和多态
03-25
Python中的封装、继承和多态是面向对象编程的重要概念。下面我将为你介绍一下它们： 1. 封装（Encapsulation）： 封装是将数据和对数据的操作封装在一个类中，通过定义类的属性和方法来实现。封装可以隐藏类的内部...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

高二的笔记

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

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

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

打赏作者

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

抵扣说明：

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

余额充值