【C++】——继承

最新推荐文章于 2024-10-06 14:42:09 发布
最新推荐文章于 2024-10-06 14:42:09 发布
阅读量964 收藏 12
点赞数 21
文章标签： c++ java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73953114/article/details/142674831
版权

🌇个人主页：_麦麦_ 

📚今日名言：你最可爱。我说时来不及思索，而思索之后，还是这样说。——普希金

目录

一、前言

二、正文

2.1继承的概念及定义

2.1.1继承的概念

2.1.2继承定义

2.1.2.1定义的格式

2.1.2.2 继承关系和访问限定符

2.1.2.3 继承基类成员访问方式的变化

2.2 基类和派生类对象赋值转换 

 2.3继承中的作用域

2.4 派生类的默认成员函数

2.5 继承和友元

2.6 继承与静态成员

2.7 复杂的菱形继承及菱形虚拟继承

2.8 继承的总结和反思

三、结语

一、前言

        今天为大家带来继承的讲解，文章若有不足之处，欢迎大家给出指正！

二、正文

2.1继承的概念及定义

2.1.1继承的概念

        继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

        在下面的代码中我们定义了Preson和Student两个类，通过对Person类的复用，我们会发现在Student类中也有name，tel和age三个基类的成员变量。

class Person
{
public:
	string name="";
	string tel = "";
	size_t age=20;
};

class Student :public Person
{

private:
	string school = "";
	string ID = "";
};

int main()
{
	Student s;
	return 0;
}

 

2.1.2继承定义

2.1.2.1定义的格式

        在了解完继承的概念之后，那我们该如何进继承的定义类？其实很简单，只需要在类名后指定继承的方式和基类即可，如果有多个要继承的基类，只需要加上逗号进行分割即可。

2.1.2.2 继承关系和访问限定符

        在上面中我们提到了“继承方式”一词，对于派生类来说，既然它继承了基类的成员变量，那么对其访问的权限是怎样的呢，主要是受到两方面的影响，分别是派生类对基类的继承方式和基类中成员所在的访问限定符。这两者分别各有三种情况，对于访问限定符，相信小伙伴们在类和对象的学习中已经了解过了，对于继承方式，它的关键词与访问限定词相同。

2.1.2.3 继承基类成员访问方式的变化

         既然派生类对基类的访问受到访问限定符和继承方式两者的影响，那么具体情况是怎样的呢、从排列组合的方式来说一共有九种情况，若是一一对其进行讲解未必会有些许繁琐，下面采取一种更方便大家理解和记忆的方式来讲解这九种组合

        首先是基类成员为private成员，那么无论派生类的继承方式是哪种情况，该成员在派生类中都是不可见的。

        其次是基类成员不为private成员，那么对于它的权限主要取继承方式和访问限定符中较小的那个。比如说基类的protected成员在继承方式为public和protected下，在派生类中依旧为protected成员，但若是为private继承方式，那么在派生类中就为private成员

 

总结：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私 有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面 都不能去访问它。

2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

3. 实际下面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。

4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡 使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

类成员/继承方式piblic继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见
class Person
{
public:
	string name="";
	string tel = "";
	size_t age=20;
};

//演示一下三种继承方式
//class Student :privat Person
//class Student :protected Person
class Student :public Person
{

private:
	string school = "";
	string ID = "";
};

2.2 基类和派生类对象赋值转换 

        类和对象中，我们学习赋值重载的时候，知道了能够将一个类赋值给另一个类，那么在基类和派生类中也存在这种赋值转的过程，但是会略微有所不同，并不是在任何情况下都可以赋值转换。

        ●派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

        ●基类对象不能赋值给派生类对象。

        ●基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类 指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。（ps：这个我们后 面再讲解，这里先了解一下）

class Person
{
public:
	string name="";
	string tel = "";
	size_t age=20;
};

//演示一下三种继承方式
//class Student :privat Person
//class Student :protected Person
class Student :public Person
{

public:
	string school = "";
	string ID = "";
};

int main()
{
	Student s;
	//派生类可以赋值给基类的对象/指针/引用
	Person p = s;
	Person* pp = &s;
	Person& rp = s;
	
	//基类的成员不能赋值给派生类的对象
	Student ss = p;

	//基类的指针(引用)可以通过强制类型转换赋值给派生类的指针（引用）
	Student* ps = (Student*)pp;
	Student& rs = (Student&)rp;
	ps->school = "晶晶大学";
	rs.tel = "15842967758";
	return 0;
}

 2.3继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。

2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏， 也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

4. 注意在实际中在继承体系里面最好不要定义同名的成员。

//Person的_ID和Student的_ID构成隐藏关系

class Person
{
public:
	string _name="";
	string _tel = "";
	size_t _age=20;
	size_t _ID = 20;  //身份证号
};

class Student :public Person
{
	void Print()
	{
		cout << "学校" << _school << endl;
		cout << _ID << endl;
		cout << Person::_ID << endl;
	}
public:
	string _school = "";
	string _ID = "";	//学号
	size_t _num = 50;
};

//Student的fun与Person中的fun不构成重载，因为不是在同一作用域
//Student的fun与Person中的fun构成隐藏，成员函数满足函数名相同就构成隐藏

class Person
{
public:
	void fun()
	{
		cout << "Person::fun()" <<endl;
	}


	string _name="";
	string _tel = "";
	size_t _age=20;
	size_t _ID = 20;  //身份证号
};

class Student :public Person
{
public:

	void fun()
	{
		cout << "Student::fun()" << endl;
	}

	void Print()
	{
		cout << "学校" << _school << endl;
		cout << _ID << endl;
		cout << Person::_ID << endl;
	}
	string _school = "";
	string _ID = "";	//学号
	size_t _num = 50;
};

2.4 派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类 中，这几个成员函数是如何生成的呢？

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲 解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

注：为什么进行对象的清理工作是要先调用子类的析构函数再调用父类的析构函数，一个和原因是符合栈的顺序，父类的成员是先初始化的，而子类则是后初始化；其次是如果先调用父类的析构函数，若是子类还想对父类的成员进行操作就会出现问题，而先析构子类的话就不会出现在这样的问题，父类不存在对子类的操作需求。

class Person
{
public:
	Person(const string& name, const string& tel,const size_t age)
		:_name(name)
		,_tel(tel)
		,_age(age)
	{}

	Person(const Person& P)
		:_name(P._name)
		, _tel(P._tel)
		, _age(P._age)
	{}

	Person& operator=(const Person& P)
	{
		if (this != &P)
		{
			_name = P._name;
			//...
		}
		
		return *this;
	}
	void fun()
	{
		cout << "Person::fun()" <<endl;
	}

	string _name;
	string _tel = "";
	size_t _age=20;
};

class Student :public Person
{
public:
	Student(const string& school, const string& ID, const size_t num)
		:Person("","",0)	//Personl类没有默认构造需要显示调用
		, _school("")
		, _ID(ID)
		, _num(num)
	{}

	Student(const Student& S)
		: Person(S)	//调用基类的拷贝构造
		,_school(S._school)
		,_ID(S._ID)
		,_num(S._num)
	{}

	Student& operator==(const Student  S)
	{
		if (this != &S)
		{
			Person::operator=(S); //调用基类的拷贝构造
			_school = S._school;
			//...
		}
		return *this;
	}

	void fun()
	{
		cout << "Student::fun()" << endl;
	}

	void Print()
	{
		cout << "学校" << _school << endl;
		cout << _ID << endl;
	}
	string _school ;
	string _ID = "";	//学号
	size_t _num = 50;
};

2.5 继承和友元

         注意的是虽基类中的成员可以被子类所继承，但是友元关系不能继承，也就是基类友元不能访问子类私有和保护成员，形象的一点可以说父亲的朋友不一定是你的朋友。

class Person
{
public:
 friend void Display(const Person& p, const Student& s);
protected:
 string _name; // 姓名
};

class Student : public Person
{
protected:
 int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
 cout << p._name << endl;
 cout << s._stuNum << endl;
}

void main()
{
 Person p;
 Student s;
 Display(p, s);
}

2.6 继承与静态成员

       在类和对象当中还有一类特殊的成员，就是静态成员，它在继承的时候也有一定的特殊性。即基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。

        通过这样静态函数这样的特性，我们可以统计父类和子类共实例化了多少次，代码见下。

class Person
{
public :
 Person () {++ _count ;}
protected :
 string _name ; // 姓名
public :
 static int _count; // 统计人的个数。
};

int Person :: _count = 0;
class Student : public Person
{
protected :
 int _stuNum ; // 学号
};

class Graduate : public Student
{
protected :
 string _seminarCourse ; // 研究科目
};


void TestPerson()
{
 Student s1 ;
 Student s2 ;
 Student s3 ;
 Graduate s4 ;
 cout <<" 人数 :"<< Person ::_count << endl;
 Student ::_count = 0;
 cout <<" 人数 :"<< Person ::_count << endl;
}

2.7 复杂的菱形继承及菱形虚拟继承

         大家都知道C++是一门面向对象的语言，在生活中确实我们也会面对继承的情况，比如说一名在校的学生的信息，既要包括名字，性别等基础信息，又要有学校，学院，学号等学生信息。上述的这种继承属于单继承，除了它之外，我们还可能面临多继承。也就是说一个类对象可能继承多个基类，在生活中，就好比说一个人可以有两份工作，一份主职，一份兼职，都是他的工作。正常来说，多继承的确也是我们生活中常见的现象，但是随着不断地开发，逐渐发现多继承也有其不足之处，也就是会出现菱形继承的情况。

        什么菱形继承呢？就是子类的多个父类拥有同一个基类，这样就会导致基类成员的冗余，即数据的冗余，对于子类而言还会出现二义性的问题，即不知道该访问哪一个。

 

 

class Person
{
public :
 string _name ; // 姓名
};


class Student : public Person
{
protected :
 int _num ; //学号
};


class Teacher : public Person
{
protected :
 int _id ; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected :
 string _majorCourse ; // 主修课程
};

void Test ()
{
 // 这样会有二义性无法明确知道访问的是哪一个
 Assistant a ;
 a._name = "peter";
 
 // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
 a.Student::_name = "xxx";
 a.Teacher::_name = "yyy";
}

        为了解决菱形继承出现的多义性和数据冗余这一情况，C++引入了虚拟继承，通过虚拟继承就可以解决上面的问题，不过需要注意的是，虚拟继承不要在其他地方去使用。

class Person
{
public :
 string _name ; // 姓名
};

class Student : virtual public Person
{
protected :
 int _num ; //学号
};

 class Teacher : virtual public Person
{
protected :
 int _id ; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected :
 string _majorCourse ; // 主修课程
};

void Test ()
{
 Assistant a ;
 a._name = "peter";
}

2.8 继承的总结和反思

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱 形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

2. 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java。

3. 继承和组合

●public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。

●组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

●优先使用对象组合，而不是类继承 。

●继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

●对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

●实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

// Car和BMW Car和Benz构成is-a的关系
   class Car{
   protected:
   string _colour = "白色"; // 颜色
   string _num = "陕ABIT00"; // 车牌号
   };
   
   class BMW : public Car{
   public:
   void Drive() {cout << "好开-操控" << endl;}
   };
   
   class Benz : public Car{
   public:
   void Drive() {cout << "好坐-舒适" << endl;}
   };
   
   // Tire和Car构成has-a的关系
   
   class Tire{
   protected:
       string _brand = "Michelin";  // 品牌
       size_t _size = 17;         // 尺寸
   
   };
   
   class Car{
   protected:
   string _colour = "白色"; // 颜色
   string _num = "陕ABIT00"; // 车牌号
    Tire _t; // 轮胎
   };

三、结语

        到此为止，关于优先级队列的讲解就告一段落了，至于其他的内容，小伙伴们敬请期待呀！

        关注我 _麦麦_分享更多干货：_麦麦_-CSDN博客
        大家的「关注❤️ + 点赞👍 + 收藏⭐」就是我创作的最大动力！谢谢大家的支持，我们下期见！ 最后祝大家国庆节快乐，还有小晶晶，玩得开心嗷！

_麦麦_
关注
C++.继承——虚继承
xiaoyu1381的博客
10-18 2092
C++.继承——虚继承
C++——继承
花想云的博客
05-31 1105
在C++中，既然将之取名为继承，自然是因为与现实中的继承有某些相似的地方。 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，从而产生一个新的类，称之派生类。 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
C++——继承（超详细）
sqm_C的博客
07-04 1880
看了上面的案例，我们大概知道了继承的概念，那么我们接下来就来看看继承的定义：下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。由上图，我们发现继承方式好像跟访问限定符一样也是三种，那是不是就有九种情况呢？那我们如何分辨呢?总结：1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
C++——继承和多态
weixin_57133901的博客
03-07 2404
多态： 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。 多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。 1.1两种多态： 1.1.1编译时多态（早绑定）： 编译时的多态通过函数的重载和运算符的重载来实现的。 就像是未出生的男女孩定下的娃娃亲。 1.1.2运行时多态（晚绑定）
用人话讲C++——继承（5）
yjnlovepy的博客
06-17 603
用人话讲C++——继承（5）
c++——私有继承
afootball的博客
11-05 4236
私有继承：使用私有继承，基类的公有成员和保护成员都将成为派生类的私有成员，只可以在派生类的成员函数中使用 一、私有继承示例 class Student : private std::string,private std::valarray<double> { public: ... } //student以私有继承的方式继承了string类和valarray类 //stduent是多重继承（使用多个基类的继承被称为多重继承） 示例student类 class Student { privat
C++编程——继承
professor_tao的博客
04-25 4265
文章目录1. 继承的基本语法2. 继承方式 继承的知识点结构： 继承是面向对象三大特性之一，例如动物类下可以有猫类、狗类。显然猫类、狗类都具有动物类的属性，于此同时，也就有自己独特的属性。这个时候，猫类、狗类就是继承于动物类，采用继承的技术，可以减少重复的代码。 1. 继承的基本语法 语法：class 子类：继承方式 基类 继承示例： 一般网页都有很多部分相似的，我们可以将这些相似的部分抽象出来，作为一个基类。然后子类只需要继承基类，在基类的基础上添加自身其他的属性或者方法就可以实现基本的功能，同时减少
C++——三种继承方式
JAN6055的博客
01-25 1882
三种继承方法
C++核心——继承
wtzhu_13的博客
03-28 1492
C++核心——继承 继承其实最简单的理解就是一种代码复用，之前语句复用的时候，我们利用函数实现代码复用，继承就是在类的基础上实现代码的复用，就是把几个类共有的部分提取出来，实现复用，简化代码结构。当然这是对继承最简单的一种理解，继承还有很多其他的用途。 继承的基本语法 首先在没用继承的时候我们定义两个类，汽车和飞机，有共同的属性名称，共同的行为就是运输，但是飞机可以飞，汽车可以倒车（当然现在有的飞...
C++语法——详解虚继承
热门推荐
weixin_61857742的博客
10-23 2万+
一.什么是虚继承所谓虚继承（virtual）就是子类中只有一份间接父类的数据。该技术用于解决多继承中的父类为非虚基类时出现的数据冗余问题，即菱形继承问题。，那么，当我们用D实例化对象调用a时，编译会报错，因为发生了混淆。除非指定类域B或C。当然指定A也可以，因为默认会从第一个父类中找。此时，D的实例化对象内部结构如下：而当我们使用虚继承时，结构是下图这样，D中只有一份父类A，当我们调用A中数据时，并不会发生冗余。
详解C++基础——类继承
12-31
好吧，本系列博客已经变成了《C++ Primer Plus》的读书笔记，尴尬。在使用C语言时，多通过添加库函数的方式实现代码重用，但有一个弊端就是原来写好的代码并不完全适用于现在的情况。OOP设计思想中类的继承相比来说...
详解C++基础——类继承中方法重载
08-26
C++ 基础知识点 —— 类继承中方法重载 在 C++ 编程语言中，类继承是指在已有的类基础上创建新的类，新类继承了原来类的成员变量和成员函数。然而，在继承的过程中，我们需要注意到方法重载的概念。方法重载...
c++——继承类中的子对象和基类对象的初始化
snail
09-16 4219
为什么研究临时对象？ 主要是为了提高程序的性能以及效率，因为临时对象的构造与析构对系统开销也是不小的，所以我们应该去了解它们，知道它们如何造成，从而尽可能去避免它们。临时对象是可以被编译器感知的。 下面的例子，可能有人认为"int temp"是"临时对象"，但是其实不然，"int temp"仅仅是swap函数的局部变量。 #include void swap( int &a,
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 157
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
【C语言】数据类型和变量
2302_76713442的博客
10-06 944
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 930
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
最新发布
白乐天_ξ( ✿＞◡❛)的博客
10-06 400
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
C - Separated Lunch
m0_74304371的博客
10-05 225
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 410
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
C++教程：面向对象编程进阶——继承与多态
1. 第11章 继承与派生：这一章讲解了面向对象编程中的核心概念——继承，即一个类可以从已存在的类继承属性和方法，派生出新的类，从而减少代码重复和提升代码复用性。 2. 第12章 多态性与虚函数：多态性是面向对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_麦麦_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值