C++——继承

已于 2022-07-26 17:29:39 修改
阅读量175 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 开发语言 后端
于 2022-01-27 22:31:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56663697/article/details/122713949
版权

文章目录

继承的概念及定义

继承的概念

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

例如下面代码中Student和Teachar类就继承了Person类

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18; // 年龄
};
class Student : public Person
{
protected: 
	int _stuid; // 学号
};
class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
int main()
{
	Student s;
	Teacher t;
	return 0;
}

通过调试窗口可以看出Student和Teachar类中包含Person类的成员

在这里插入图片描述

继承定义

定义格式

在这里插入图片描述
注意： Person是父类，也称作基类。Student是子类，由基类派生而来的，也称作派生类。

继承关系和访问限定符

访问方式有以下三种

  1. public访问
  2. protected访问
  3. private访问

继承的方式也有三种：

  1. public继承
  2. protected继承
  3. private继承

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

基类被不同访问限定符修饰，当它以不同的方式继承到派生类时，该类成员在派生类中的访问方式会发生改变，如下图。
在这里插入图片描述
注意：

  1. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
  2. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  3. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

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

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

在这里插入图片描述

注意： 基类对象不能赋值给派生类对象，基类的指针可以通过强制类型转换赋值给派生类的指针，但是此时基类的指针必须是指向派生类的对象才是安全的。

class Person
{
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _No; // 学号
};
int main()
{
	Student s;
	Person p = s;     //派生类对象赋值给基类对象
	Person* ptr = &s; //派生类对象赋值给基类指针
	Person& ref = s;  //派生类对象赋值给基类引用

	//2.基类对象不能赋值给派生类对象
	//s = p;

	// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
	ptr = &s;
	Student* ps1 = (Student*)ptr; // 这种情况转换时可以的。
	ps1->_No = 10;

	ptr = &p;
	Student* ps2 = (Student*)ptr; // 这种情况转换时虽然可以，但是会存在越界访问的问题
	ps2->_No = 10;
}

继承中的作用域

在继承体系中基类和派生类都有独立的作用域，子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

例如：下面代码中访问_num成员只会访问到派生类

// 基类
class Person
{
protected:
	string _name = "小李"; 
	int _num = 111; 
};
// 派生类
class Student : public Person
{
public:
	void Print()
	{
		cout <<  _name << endl;
		cout << _num << endl;
	}
protected:
	int _num = 999; 
};
int main()
{
	Student s1;
	s1.Print();
	return 0;
};

在这里插入图片描述

如果想要访问基类成员需要添加作用域限定符

class Student : public Person
{
public:
	void Print()
	{
		cout <<  _name << endl;
		cout <<  Person::_num << endl;// 访问基类成员
		// cout << _num << endl;
	}
protected:
	int _num = 999; 
};

在这里插入图片描述

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

例：下文代码中，调用成员函数fun调用的是子类成员函数，若要调用父类成员函数需要用作用域限定符指定类域。

//父类
class A {
public:
	void fun()
	{
		cout << "func(A)" << endl;
	}
};
// 子类
class B : public A {
public:
	void fun()
	{
		  cout << "func(B)" << endl;
	}
};
int main()
{
	B b;
	b.fun();	//直接调用子类当中的成员函数fun
	b.A::fun(); //指定调用父类当中的成员函数fun
	return 0;
};

注意： 父类中的fun和子类中的fun不是构成函数重载，因为它们在不同的作用域，在实际中在继承体系里面最好不要定义同名的成员。

派生类的默认成员函数

默认成员函数，即我们不写编译器会自动生成的函数，类当中的默认成员函数有以下六个：

在这里插入图片描述

派生类中的默认成员函数和普通类中的默认成员函数有许多不同之处

例：

// 基类
class Person
{
public:
	// 构造函数
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	// 拷贝构造函数
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	// 赋值运算符重载函数
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}
	// 析构函数
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};
// 派生类
class Student : public Person
{
public:
	// 构造函数
	Student(const char* name, int num)
		: Person(name)//调用基类的构造函数初始化基类的那一部分成员
		, _num(num)
	{
		cout << "Student()" << endl;
	}
	// 拷贝构造函数
	Student(const Student& s)
		: Person(s)//调用基类的拷贝构造函数完成基类成员的拷贝构造
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
	//赋值运算符重载函数
	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);//调用基类的operator=完成基类成员的赋值
				_num = s._num;
		}
		return *this;
	}
	//析构函数
	~Student()
	{
		cout << "~Student()" << endl;
		//派生类的析构函数会在被调用完成后自动调用基类的析构函数
	}
protected:
	int _num; //学号
};

总结：

  1. 派生类的构造函数被调用时，会自动调用基类的构造函数初始化基类的那一部分成员，如果基类当中没有默认的构造函数，则必须在派生类构造函数的初始化列表当中显示调用基类的构造函数。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类成员的拷贝构造。
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。保证派生类对象先清理派生类成员，再清理基类成员的顺序 。
  5. 派生类对象初始化先调用基类构造再调派生类构造。
  6. 派生类对象在析构时，会先调用派生类的析构函数再调用基类的析构函数。

在编写派生类的默认成员函数时，需要注意以下几点：

  1. 派生类和基类的赋值运算符重载函数因为函数名相同构成隐藏，因此在派生类当中调用基类的赋值运算符重载函数时，需要使用作用域限定符进行指定调用。
  2. 析构函数名会被统一处理为destructor();。因此，派生类和基类的析构函数也会因为函数名相同构成隐藏，若是我们需要在某处调用基类的析构函数，那么就要使用作用域限定符进行指定调用。
  3. 派生类的拷贝构造函数和operator= 中调用基类拷贝构造函数是一个切片行为，都是将派生类对象直接赋值给基类的引用。

说明：

  • 基类的构造函数、拷贝构造函数、赋值运算符重载函数我们都可以在派生类当中自行进行调用，而基类的析构函数是当派生类的析构函数被调用后由编译器自动调用的，我们若是自行调用基类的构造函数就会导致基类被析构多次的问题。
  • 我们知道，创建派生类对象时是先创建的基类成员再创建的派生类成员，编译器为了保证析构时先析构派生类成员再析构基类成员的顺序析构，所以编译器会在派生类的析构函数被调用后自动调用基类的析构函数。

继承与友元

友元关系不能继承，也就是说基类的友元可以访问基类的私有和保护成员，但是不能访问派生类的私有和保护成员。

class Student;
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;// 不可以访问
}

若想访问需在派生类Student中添加友元

class Student : public Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum; // 学号
};

继承与静态成员

基类定义了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; // 研究科目
};
int main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}

在这里插入图片描述

继承的方式

单继承： 一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
多继承： 一个子类有两个或以上直接父类时称这个继承关系为多继承
在这里插入图片描述

菱形继承： 菱形继承是多继承的一种特殊情况。
在这里插入图片描述
从上面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。

例：

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";
}

对此，我们可以显示指定访问哪个父类的_name成员

//显示指定访问父类的成员
 a.Student::_name = "xxx";
 a.Teacher::_name = "yyy";

虽然用此方法可以解决二义性问题，但是它不能解决数据冗余的问题。因为在Assistant对象的Person成员始终存在两份。

虚拟继承

为了解决上述菱形继承的问题，这里引入了虚拟继承，如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。

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";
}

虚拟继承原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型

测试代码：

class A {
public:
	int _a;
};
// class B : public A
class B : virtual public A 
{
public:
	int _b;
};
// class C : public A
class C : virtual public A 
{
public:
	int _c;
};
class D : public B, public C 
{
public:
	int _d;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余

在这里插入图片描述

我们再来看看虚拟继承

在这里插入图片描述

这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存偏移量。通过偏移量可以找到下面的A。

我们若是将D类对象赋值给B类对象，在这个切片过程中，就需要通过虚基表中的第二个数据找到公共虚基类A的成员，得到切片后该B类对象在内存中仍然保持这种分布情况。

虚拟继承的原理解释图：

在这里插入图片描述

继承的总结和反思

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

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

继承和组合

public继承是一种is-a的关系，每个派生类对象都是一个基类对象；组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

例如：车和奔驰，车是奔驰的构成is-a的关系，适用继承

class Car
{
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
};
class Benz : public Car
{
public:
	void Drive() { cout << "好坐-舒适" << endl; }
};

车和轮胎，车上有轮胎构成has-a的关系，适合使用组合。

class Tire
{
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17; // 尺寸

};
class Car
{
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
	Tire _t; // 轮胎
};

若是两个类之间既满足is-a,又满足has-a,优先使用对象组合，而不是类继承，原因如下

  1. 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
  2. 组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
  3. 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承。另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

笔试面试题

  1. 什么是菱形继承？菱形继承的问题是什么？

菱形继承是多继承的一种特殊情况，两个子类继承同一个父类，而又有子类同时继承这两个子类，我们称这种继承为菱形继承。
菱形继承因为子类对象当中会有两份父类的成员，因此会导致数据冗余和二义性的问题。

  1. 什么是菱形虚拟继承？如何解决数据冗余和二义性？

菱形虚拟继承是指在菱形继承中使用虚拟继承(virtual)的继承方式，菱形虚拟继承对于D类对象当中重复的A类成员只存储一份，然后采用虚基表指针和虚基表使得D类对象当中继承的B类和C类可以找到自己继承的A类成员，从而解决了数据冗余和二义性的问题。

  1. 继承和组合的区别？什么时候用继承？什么时候用组合？

继承是一种is-a的关系，而组合是一种has-a的关系。如果两个类之间是is-a的关系，使用继承；如果两个类之间是has-a的关系，则使用组合；如果两个类之间的关系既可以看作is-a的关系，又可以看作has-a的关系，则优先使用组合。

小倪同学 -_-
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】关于继承的本质和原理
GoingJack博客
07-16 1842
关于C++的继承的理论基础 继承的本质：代码的复用 所有C++的类或者说是所有面向对象类与类之间的关系总结起来有俩种 1，组合 a part of ... ... 一部分的关系 2，继承 a kind of... ... 一种的关系 关于继承方式和访问限定罗列如下 继承方式 基类的访问限定 派生类的访问限定 (main)外部的访问限定 public ...
C++继承（+继承原理超详解哦）
最新发布
weixin_73450183的博客
12-17 2305
继承是面向对象编程中一种代码复用的重要手段。继承是在保持原有类（基类或父类）特性的基础上进行拓展，增加属性或方法，从而产生一个新的类（派生类或子类）。继承体现了面向对象编程的层次型结构，是由简单到复杂的过程
C++中继承的本质和原理
the_lane的博客
02-20 675
本质：代码的复用 class A { public: int ma; protected: int mb; private: int mc; }; class B :public A {//公有继承 A:父类/基类 B:子类/派生类 public: int md; protected: int me; private: int mf; }; 其中A有12个字节（三个整型成员变量），B有自己的三个成员变量和从A继承而来的三个成员变量，故有24个字节 从基类继承来成员时还附带了基类的作用域，因此可
c++：继承（超详解）
热门推荐
qq_62718027的博客
07-22 7万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
C++之继承详解(万字讲解)
be_a_struggler的博客
11-11 5884
C++继承详解，继承概念与定义，六大默认函数，基类和派生类赋值转换，继承中的作用域，继承与友元，继承与静态成员，菱形虚拟继承，菱形继承，菱形继承的深度剖析
详解C++基础——类继承
12-31
好吧，本系列博客已经变成了《C++ Primer Plus》的读书笔记，尴尬。在使用C语言时，多通过添加库函数的方式实现代码重用，但有一个弊端就是原来写好的代码并不完全适用于现在的情况。OOP设计思想中类的继承相比来说...
详解C++基础——类继承中方法重载
08-26
C++ 基础知识点 —— 类继承中方法重载 在 C++ 编程语言中，类继承是指在已有的类基础上创建新的类，新类继承了原来类的成员变量和成员函数。然而，在继承的过程中，我们需要注意到方法重载的概念。方法重载...
C++——图书管理系统课程设计
09-26
它的核心特性包括类（class）、封装、继承、多态性等，这些都是实现图书管理系统的关键。 在设计图书管理系统时，我们首先需要定义几个关键的数据结构，如书籍（Book）、读者（Reader）和借阅记录（BorrowRecord）...
C++学习笔记——继承和组合
06-06
组合和继承的主要目的是为了代码的重用。组合是将其他类的对象作为成员使用，继承是子类可以使用父类的成员方法。
QtC++回合制小游戏——继承与多态的练习
04-11
在本项目"QtC++回合制小游戏——继承与多态的练习"中，我们将深入探讨C++编程语言中的两个核心概念：继承与多态。这是一个非常实用的学习方式，通过一个可交互的游戏场景来实践这些理论知识，使得学习过程更加生动...
c++————————笔记
01-12
根据提供的文档内容，我们可以归纳出一系列关于C++的重要知识点，这些知识点主要涵盖了C++的基础语法、数据类型、内存管理、程序结构以及高级特性如类、继承与多态等。下面将详细阐述这些知识点： ### 1. 引言 C++...
C++经典实例——体现继承和多态
07-30
这个名为“C++经典实例——体现继承和多态”的资源显然是为了帮助开发者深入理解和应用这两个关键特性。下面我们将详细探讨这两个主题以及它们在实际编程中的应用。 首先，我们来看“继承”。继承是面向对象设计的...
01第1章 初识C++——C++程序设计入门
12-01
本章"初识C++——C++程序设计入门"是学习C++之旅的起点，旨在为初学者构建坚实的基础。 首先，C++程序的基本结构通常包括预处理指令、函数定义、变量声明和控制流语句。预处理指令以`#`开头，如`#include`用于引入...
C++ 类的继承友元模版举例
09-22
C++类的继承、友元模板和虚函数的实现示例 本文将通过一个示例程序，讲解C++类的继承、友元和虚函数的使用，展示了C++类继承的基本概念和实现方法。 一、类的继承 在C++中，类的继承是指一个类可以继承另一个类的...
超越C++——C++/CLI
05-11
C++/CLI通过语言层的语法映射到CTS，使得C++程序员可以创建和使用CTS的三种基本类型：多态引用类型（用于类继承）、非多态值类型（用于高效的数据类型，如数值类型）和抽象接口类型（定义一组公共操作的接口）。...
c++多态实现的机制
zyq0335的专栏
06-12 4万+
1 什么是多态？ 多态性可以简单的概括为“1个接口，多种方法”，在程序运行的过程中才决定调用的机制 程序实现上是这样，通过父类指针调用子类的函数，可以让父类指针有多种形态。 2 实现机制 举一个例子： #include class animal { public: void sleep() { cout } void breathe() { cout } };
关于C++类内部的一些工作机制
Anna的博客
01-17 283
首先， 类内有六个默认的函数： 1、构造函数 2、拷贝构造 3、析构函数 4、赋值语句 5、取值运算符 6、取常地址运算符 然后，为了解释好下面的一些小知识点要先创建一个TEST类，如下。 class Test { public: Test(int d = 0) : data(d) { cout<<"Create Obj : "<<this<<endl; }
Java继承的底层原理浅析
星是河的眼的博客
09-10 286
前言 这两天在重温java继承,做了几个实例,特别是在做多态实例时对java底层产生了猜想,有时候会根据我的猜想出结果,有时候会有差错,赶紧查阅资料,浅析一下继承的底层. 方法区概念的引入 方法区,与java堆一样,是各个线程共享的内存区域. 方法区在JVM启动的时候被创建,并且它的实际的物理内存空间中和java堆区一样都可以是不连续的. 方法区的大小决定了系统可以保存多少个类,如果系统定义了太多的类,导致方法区溢出,虚拟机同样会抛出内存溢出错误.(方法区加载大量的第三方的jar包,tomcat部署过多,
Java——类的继承底层原理与使用细节
yanyongfu523的博客
03-26 701
类的特征之一——继承 关键字extends，表示Sab类继承了Base类，则Sab为Base的子类，Base为Sab的父类。继承在现实中是合法获得前人的财产，地位，权利等，在java中继承是子类获得父类的成员变量和成员方法。 Sab类中没有n2和info方法，但sab对象可以调用，说明sab对象中有n2成员变量和info成语方法。 输出结果也显示sab对象调用了n2和info方法。 在jvm内存中先加载所有类的父类Object，再加载Sab的父类Base,创.
C++中的继承与派生：多继承解析
它允许我们定义一般性的基类，然后根据需要创建具体的派生类，从而实现面向对象的核心原则——抽象、封装、继承和多态性。通过理解并熟练运用这些概念，开发者能够构建更加健壮和易于维护的软件系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值