专题：C++常见最全类和对象中运算符的重载+完整代码

C++中运算符和输入输出流的重载实践
原创 已于 2023-04-25 21:36:21 修改 · 1.2k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

于 2023-02-24 21:08:11 首次发布
本文详细介绍了C++中运算符重载的两种方法，即成员函数法和类外友元函数法，并通过复数类实例展示了加减乘除以及大于、小于、等于和不等于运算符的重载。同时，文章还讲解了输入输出流的重载，包括输入流和输出流的友元函数实现方式，以读取和显示复数类对象为例。

目录

一.运算符重载

1.1.“+”“-”“*”“/”重载

成员函数实现方法：

类外友元函数实现方法：

1.2“>”“<”重载

成员函数实现方法

类外友元函数实现方法 

1.3“==”和“!=”的重载

成员函数实现方法

类外友元函数实现方法

二.输入输出流重载

2.1输入流重载：

2.2输出流重载：

一.运算符重载

运算符重载一般有两种方法，分别是成员函数法和类外函数友元法。

成员函数法，顾名思义，就是将重载定义为类的函数成员；

类外友元函数法，就是利用类外单独的函数实现重载功能，并将函数和类建立起友元关系。

两种方法的显著区别就在于：

1.解决访问私有（保护）成员权限问题；

2.传入参数个数不同；（其实第二点区别派生于第一点）

下面对于每种常见的运算符的重载，都会给出两种方法的代码。

对于运算符重载，一般格式为：

1.类内成员函数：

class

{

        ……

public：

        类名 operator 将要重载的运算符 （类名同型的数据类型 &）

        {

                类名同型的数据类型  结果变量；

                计算结果；

                return 结果变量；

        }

}

int main（）{}

2.类外友元函数：

class

{

        ……

public：

        ……

        friend 类名 operator 将要重载的运算符 （类名同型数据类型 &对象1，类名同型数据类型&对象2）；

}

类名 operator 将要重载的运算符 （类名同型数据类型 &对象1，类名同型数据类型&对象2）{

        类名同型的数据类型 结果变量；

        进行二元运算并将结果赋值给结果变量；

        返回结果变量；

}

int main （）{}

以下是具体例子：

1.1.“+”“-”“*”“/”重载

成员函数实现方法：

#include <iostream>
using namespace std;
class complex
{
protected:
	double real, imag;
public:
	complex(double a = 0, double b = 0)
	{
		this->real = a;
		this->imag = b;
	}
	void showcomplex()
	{
		cout << "(" << this->real << "," << this->imag << "i)" << endl;
	}
	//重载运算符
	complex operator+(complex&);
	complex operator-(complex&);
	complex operator*(complex&);
	complex operator /(complex&);
};
inline complex complex::operator +(complex& c)
{
	complex temp;
	temp.real = this->real + c.real;
	temp.imag = this->imag + c.imag;
	return temp;
}
inline complex complex::operator -(complex& c)
{
	complex temp;
	temp.real = this->real - c.real;
	temp.imag = this->imag - c.imag;
	return temp;
}
inline complex complex::operator *(complex& c)
{
	complex temp;
	temp.real = this->real * c.real - this->imag * c.imag;
	temp.imag = this->real * c.imag + this->imag * c.real;
	return temp;
}
inline complex complex::operator/(complex& c)
{
	if (c.real == 0 && c.imag == 0)
	{
		cout << "error" << endl;
		exit(0);
	}
	else
	{
		complex temp;
		double under = c.real * c.real + c.imag * c.imag;
		temp.real = (this->real * c.real + this->imag * c.imag) / under;
		temp.imag = (this->imag * c.real - this->real * c.imag) / under;
		return temp;
	}
}
int main()
{
	system("color 0A");
	complex a(1, 2), b(2, 3), c;
	c = a + b;
	c.showcomplex();
	c = a - b;
	c.showcomplex();
	c = a * b;
	c.showcomplex();
	c = a / b;
	c.showcomplex();
	return 0;
}

类外友元函数实现方法：

#include<iostream>
using namespace std;
class complex
{
private:
	double real, imag;
public:
	complex(double a = 0, double b = 0)
	{
		this->real = a;
		this->imag = b;
	}
	void showcomplex()
	{
		cout << "(" << this->real << "," << this->imag << "i)" << endl;
	}
	friend complex operator +(complex&, complex&);
	friend complex operator -(complex&, complex&);
	friend complex operator *(complex&, complex&);
	friend complex operator /(complex&, complex&);
};
complex operator+(complex& a, complex& b)
{
	complex temp;
	temp.real = a.real + b.real;
	temp.imag = a.imag + b.imag;
	return temp;
}
complex operator-(complex& a, complex& b)
{
	complex temp;
	temp.real = a.real - b.real;
	temp.imag = a.imag - b.imag;
	return temp;
}
complex operator*(complex& a, complex& b)
{
	complex temp;
	temp.real = a.real * b.real - a.imag * b.imag;
	temp.imag = a.real * b.imag + a.imag * b.real;
	return temp;
}
complex operator/(complex& a, complex& b)
{
	if (b.real == 0 && b.imag == 0)
	{
		cout << "error" << endl;
		exit(0);
	}
	else
	{
		complex temp;
		double under = b.real * b.real + b.imag * b.imag;
		temp.real = (a.real * b.real + a.imag * b.imag) / under;
		temp.imag = (a.imag * b.real - a.real * b.imag) / under;
		return temp;
	}
}
int main()
{
	system("color 0A");
	complex a(1, 2), b(2, 3), c;
	c = a + b;
	c.showcomplex();
	c = a - b;
	c.showcomplex();
	c = a * b;
	c.showcomplex();
	c = a / b;
	c.showcomplex();
	return 0;
}

运行结果：

 

1.2“>”“<”重载

成员函数实现方法

#include<iostream>
using namespace std;
class student
{
private:
	string name;
	double scores;
public:
	student()
	{
		this->name = "unknown name";
		this->scores = 0;
	}
	student(string name, double scores)
	{
		this->name = name;
		this->scores = scores;
	}
	void operator >(student& s)
	{
		cout << "operator>" << endl;
		if (this->scores > s.scores)
			cout << "true" << endl;
		else
			cout << "false" << endl;
	}
	void operator<(student& s)
	{
		cout << "operator<" << endl;
		if (this->scores < s.scores)
			cout << "true" << endl;
		else
			cout << "false" << endl;
	}
};
int main()
{
	system("color 0A");
	student a("zhang", 100);
	string name;
	double scores;
	cin >> name >> scores;
	student b(name, scores);
	a > b;
	a < b;
	return 0;
}

类外友元函数实现方法 

#include<iostream>
using namespace std;
class student
{
private:
	string name;
	double scores;
public:
	student()
	{
		this->name = "unknown name";
		this->scores = 0;
	}
	student(string name, double scores)
	{
		this->name = name;
		this->scores = scores;
	}
	friend void operator >(student& a, student& b);
	friend void operator <(student& a, student& b);
};
void operator >(student& a, student& b)
{
	cout << "operator>" << endl;
	if (a.scores > b.scores)
		cout << "true" << endl;
	else
		cout << "false" << endl;
}
void operator <(student& a, student& b)
{
	cout << "operator>" << endl;
	if (a.scores < b.scores)
		cout << "true" << endl;
	else
		cout << "false" << endl;
}
int main()
{
	system("color 0A");
	student a("zhang", 100);
	string name;
	double scores;
	cin >> name >> scores;
	student b(name, scores);
	a > b;
	a < b;
	return 0;
}

运行结果：

 

 

1.3“==”和“!=”的重载

成员函数实现方法

#include<iostream>
using namespace std;
class student
{
private:
	int ID;
	string name;
public:
	student()
	{
		this->ID - 0;
		this->name = "unknown name";
	}
	student(int ID, string name)
	{
		this->ID = ID;
		this->name = name;
	}
	bool operator ==(student& s)
	{
		return ((this->ID == s.ID) && (this->name == s.name)) ? true : false;
	}
	bool operator !=(student& s)
	{
		return ((this->ID != s.ID) || (this->name != s.name)) ? true : false;
	}
};
int main()
{
	system("color 0A");
	student a(1, "zhang");
	int ID; string name;
	while(1)
	{
		cin >> ID >> name;
		student b(ID, name);
		cout << "判断a==b:" << (a == b) << endl;
		cout << "判断a!=b:" << (a != b) << endl;
	}
	return 0;
}

类外友元函数实现方法

#include<iostream>
using namespace std;
class student
{
private:
	int ID;
	string name;
public:
	student()
	{
		this->ID - 0;
		this->name = "unknown name";
	}
	student(int ID, string name)
	{
		this->ID = ID;
		this->name = name;
	}
	friend bool operator ==(student&, student&);
	friend bool operator !=(student&, student&);
};
bool operator ==(student& s1, student& s2)
{
	return ((s1.ID == s2.ID) && (s1.name == s2.name)) ? true : false;
}
bool operator!=(student& s1, student& s2)
{
	return ((s1.ID != s2.ID) || (s1.name != s2.name)) ? true : false;
}
int main()
{
	system("color 0A");
	student a(1, "zhang");
	int ID; string name;
	while(1)
	{
		cin >> ID >> name;
		student b(ID, name);
		cout << "判断a==b:" << (a == b) << endl;
		cout << "判断a!=b:" << (a != b) << endl;
	}
	return 0;
}

二.输入输出流重载

输入输出流重载方法比较固定，一般格式为：

1.输入流重载：

class 类名

{

protected：//或者private

        ……；

public：

        ……；

        friend istream & operator >>(istream&,类名同型数据类型&)；

}

istream& operator >>（istream& 变量名1，类名同型数据类型& 变量名2）

{

        ……；//实现特定功能的代码

        return 变量名1；

}

2.输出流重载：

class 类名

{

protected：//或者private

        ……；

public：

        ……；

        friend ostream &operator <<（ostream&，类名同型数据类型&）；

}

ostream& operator <<（ostream& 变量名1，类名同型数据类型& 变量名2）

{

        ……；//实现特定功能的代码

        return 变量名2；

}

2.1输入流重载：

#include <iostream>
using namespace std;
class complex
{
protected:
	double real, imag;
public:
	complex(double a = 0, double b = 0)
	{
		this->real = a;
		this->imag = b;
	}
	void showcomplex()
	{
		cout << "(" << this->real << "," << this->imag << "i)" << endl;
	}
	//重载运算符
	complex operator+(complex&);
	complex operator-(complex&);
	complex operator*(complex&);
	complex operator/(complex&);
	//重载输入输出流
	friend istream& operator >> (istream&, complex&);

};
inline complex complex::operator +(complex &c)
{
	complex temp;
	temp.real = this->real + c.real;
	temp.imag = this->imag + c.imag;
	return temp;
}
inline complex complex::operator-(complex& c)
{
	complex temp;
	temp.real = this->real - c.real;
	temp.imag = this->imag - c.imag;
	return temp;
}

inline complex complex::operator*(complex& c)
{
	complex temp;
	temp.real = this->real * c.real - this->imag * c.imag;
	temp.imag = this->real * c.imag + this->imag * c.real;
	return temp;
}
inline complex complex::operator/(complex& c)
{
	complex temp;
	double under = c.real * c.real + c.imag * c.imag;
	if (under == 0)
	{
		cout << "error";
		exit(0);
	}
	temp.real = (this->real * c.real + this->imag * c.imag) / under;
	temp.imag = (this->imag * c.real - this->real * c.imag) / under;
	return temp;
}

istream& operator >> (istream& input, complex& c)
{
	cout << "请分别输入一个复数的实部和虚部:" << endl;
	input >> c.real >> c.imag;
	return input;
}
int main()
{
	complex a, b, c;
	cin >> a >> b;
	c = a + b; c.showcomplex();
	c = a - b; c.showcomplex();
	c = a * b; c.showcomplex();
	c = a / b; c.showcomplex();
	return 0;
}

2.2输出流重载：

#include <iostream>
using namespace std;
class complex
{
protected:
	double real, imag;
public:
	complex(double a = 0, double b = 0)
	{
		this->real = a;
		this->imag = b;
	}
	void showcomplex()
	{
		cout << "(" << this->real << "," << this->imag << "i)" << endl;
	}
	//重载运算符
	complex operator+(complex&);
	complex operator-(complex&);
	complex operator*(complex&);
	complex operator/(complex&);
	//重载输入输出流
	friend istream& operator >> (istream&, complex&);
	friend ostream& operator<<(ostream&, complex&);

};
inline complex complex::operator +(complex &c)
{
	complex temp;
	temp.real = this->real + c.real;
	temp.imag = this->imag + c.imag;
	return temp;
}
inline complex complex::operator-(complex& c)
{
	complex temp;
	temp.real = this->real - c.real;
	temp.imag = this->imag - c.imag;
	return temp;
}

inline complex complex::operator*(complex& c)
{
	complex temp;
	temp.real = this->real * c.real - this->imag * c.imag;
	temp.imag = this->real * c.imag + this->imag * c.real;
	return temp;
}
inline complex complex::operator/(complex& c)
{
	complex temp;
	double under = c.real * c.real + c.imag * c.imag;
	if (under == 0)
	{
		cout << "error";
		exit(0);
	}
	temp.real = (this->real * c.real + this->imag * c.imag) / under;
	temp.imag = (this->imag * c.real - this->real * c.imag) / under;
	return temp;
}

istream& operator >> (istream& input, complex& c)
{
	cout << "请分别输入一个复数的实部和虚部:" << endl;
	input >> c.real >> c.imag;
	return input;
}
ostream& operator<<(ostream& output, complex& c)
{
	cout << "(" << c.real << "," << c.imag << "i)" << endl;
	return output;
}
int main()
{
	complex a, b, c;
	cin >> a >> b;
	c = a + b; cout << c;
	c = a - b; cout << c;
	c = a * b; cout << c;
	c = a / b; cout << c;
	return 0;
}
C++ 运算符重载
Chroniccandy的博客
10-02 940
为什么需要对运算符进行重载: C++预定义中的运算符（+ - * / …）的操作对象只局限于基本的内置数据类型(int float…),如果我们自定义了一个复数数据类型Complex comlex类有两个对象a和b，a为(3,4),b为(5,-10)。且需要求得a和b相加的值,此时c++中预定义的运算符无法对我们定义的复数类型数据ab进行运算,这个时候我们就需要对 “+” 号这个运算符进行重新定义,赋予其新的功能以满足自身需求,这个过程便称为运算符的重载。 建立一个复数类型Complex class Co
C++ 类内重载输出运算符、类外重载输出运算符的区别；及其调用区别；operator＜＜
多丰富下自己呀
05-13 2715
目录前言一、类内与类外重载运算符1.类内重载与类外重载的区别2.类外重载为什么需要友元关于模板类3.类内重载与类外重载，调用的区别二、实例实现效果：参考 前言 最后的实例利用一个模板类来实现类内与类外重载输出运算符。 其他运算符的重载类似。 如果不需要模板，去掉模板即可。 一、类内与类外重载运算符 1.类内重载与类外重载的区别 1.1类外重载一般需要类内声明友元，详见2. 1.2类内实现，调用的时候需要用对象调用，参数列表只包含一个ostream类引用。 1.3类内，作为成员函数，所以没有友元声明一说。
运算符重载的部分代码
03-10
visual basic 2005 技术内部中第六章第七节运算符重载代码。 operator部分： Module Module1 Sub Main() End Sub End Module Public Structure Fraction 'Read-Only fields Private num As Long Private den As Long 'Read-Only properties Public ReadOnly Property Numerator() As Long Get Return num End Get End Property Public ReadOnly Property Denominator() As Long Get Return den End Get End Property Sub New(ByVal numerator As Long, ByVal denominator As Long) 'Normalize the numerator and denominator If numerator = 0 Then numerator = 1 ElseIf denominator < 0 Then numerator = -numerator denominator = -denominator End If Dim div As Long = GCD(numerator, denominator) num = numerator \ div den = denominator \ div End Sub 'the greatest common divisor of two numbers (helper method) Private Function GCD(ByVal n1 As Long, ByVal n2 As Long) As Long n1 = Math.Abs(n1) n2 = Math.Abs(n2) Do 'ensure that n1>n2 If n1 < n2 Then Dim tmp As Long = n1 n1 = n2 n2 = tmp End If n1 = n1 Mod n2 Loop While n1 <> 0 End Function 'override ToString to provide a textual representation of the fraction Public Overrides Function ToString() As String If num = 0 OrElse den = 1 Then Return num.ToString Else Return String.Format("{0}/{1}", num, den) End If End Function Public Shared Operator +(ByVal f1 As Fraction, ByVal f2 As Fraction) As Fraction 'a/b+c/d=(a*d+b*c)/(b*d) Return New Fraction(f1.num * f2.den + f2.num * f1.den, f1.den * f2.den) End Operator Public Shared Operator -(ByVal f1 As Fraction, ByVal f2 As Fraction) 'a/b-c/d=(a*d-b*c)/(b*d) Return New Fraction(f1.num * f2.num, f1.den * f2.den) End Operator Public Shared Operator *(ByVal f1 As Fraction, ByVal f2 As Fraction) 'a/b * c/d=(a*c)/(b*d) Return New Fraction(f1.num * f2.num, f1.den * f2.den) End Operator Public Shared Operator /(ByVal f1 As Fraction, ByVal f2 As Fraction) Return New Fraction(f1.num * f2.den, f1.den * f2.num) End Operator End Structure
类外定义的运算符的重载
qq2250844705的博客
03-27 6254
在进行运算符的重载时，必须定义一个运算符重载函数，名字为operator，后随一个要重载的运算符。如： operator +; operator -;operator *;operator /; C++中运算符重载的规则： 1.C++中绝大部分的运算符都可以重载，不能进行重载的运算符如下： . 成员访问运算符 .*成员指针访问运算符 ：：作用域运算符 Sizeof 长度运算符 ？：
C++运算符重载（类内、外重载）
热门推荐
u014583317的博客
10-27 7万+
1.概念   运算符的重载，实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该运算符时就调用此函数来行使运算符功能。这个函数叫做运算符重载函数（常为类的成员函数）。 2.运算符重载的基本格式    返回值类型 类名::operator重载的运算符(参数表)    {    ……    }    operator是关键字，它与重载的运算符一起构成函数名。 3.运算符重载的两种方法 1.类内重载 #include <iostream> using namespa
【C++】详解运算符重载，赋值运算符重载，++运算符重载
2301_79796701的博客
04-18 2829
狂敲键盘，只为博君一笑
C++:自增运算符（++）重载
WolvenSec的博客
05-01 2191
自增运算符（++）分为前置自增和后置自增，它们两者主要的区别是：返回的值不同，以及执行自增操作的顺序不同。++前置自增运算符首先将操作数加1，然后返回自增后的值。这意味着如果你使用前置自增运算符对一个变量进行操作，你会在其他任何操作之前得到自增后的值。++后置自增运算符也会将操作数加1，但是它会返回自增前的值。这意味着如果你使用后置自增运算符对一个变量进行操作，你会在其他任何操作之后得到自增前的值。
C++实践Time类中的运算符重载参考方法
08-26
C++实践Time类中的运算符重载参考方法 在C++programming语言中，运算符重载是指可以根据不同的需求，重新定义C++语言中的运算符，以适应不同的数据类型和需求。在本篇文章中，我们将分享C++实践Time类中的运算符...
8、C++运算符重载
如是牛
12-11 1369
本章内容带领大家学习C++的运算符重载，了解C++运算符重载的应用场景和书写方式。
C++编程类和对象核心技术解析：构造函数、析构函数、拷贝构造与赋值运算符重载详解
最新发布
06-03
内容概要：本文详细介绍了C++中类和对象的中间部分知识，主要包括默认成员函数、构造函数、析构函数、拷贝构造函数以及赋值运算符重载等内容。构造函数用于对象实例化时初始化对象，C++编译器会自动生成无参默认构造...
C++常见运算符重载
m0_46369020的博客
07-15 175
运算符重载： 对已有运算符重新进行定义，赋予其另一种功能，以适应不同数据类型。 加号运算符重载： 作用：实现两个自定义数据类型相加。 1.成员函数重载 #include<iostream> using namespace std; class person{ public: person operator+(person &p)//成员函数重载 { person p1; p1.m_a=this->m_a+p.m_a; p1.m_b=this->m_b+p.m
c++ 常用的几种重载操作符
史D芬周
01-24 269
c++ 常用的几种重载操作符 运算符可以作为普通函数，朋友函数或成员函数来重载。下面的经验法则可以帮助您确定哪种形式最适合于给定的情况： 如果你重载了赋值（=），下标（[]），函数调用（（））或成员选择（ - >），那么它就是成员函数。 如果你重载一个一元运算符，那么作为一个成员函数。 如果你重载了一个修改左操作数的二元运算符（例如...
C++运算符重载
wzx19840423的专栏
08-16 559
对于二元运算符，aa@bb可以理解为aa.operator@(bb)，或者理解为operator@(aa,bb)。对于一元运算符，无论它是前缀的还是后缀的，都可以定义为无参数的非静态成员函数，或者定义为取一个参数的非成员函数。对任何前缀一元运算符@，@aa可以解释为aa.oper
解释清楚c++的重载操作符【用自己的话，解释清楚】
weixin_34318272的博客
07-16 226
C++中对于内置的变量及标准库中常见的类定义类常见的操作符含义，对于自定义的类也可以通过关键字operate重载操作符的含义。 C++中支持重载的目的 诚然操作符的重载可以通过使用函数实现同样的功能，但C++中引入重载，我想是为了增加代码的见解性和可读性。 具体的使用 在要重载的参数名儿前加operate关键字，其他与普通的函数声明类似。 参考例子 classperso...
1.7 C++基础知识_运算符重载_类外函数
一个嵌入式软件工程师的博客
07-01 660
假设有下列代码，创建了三个变量a,b,c,其中c=a+b。 事实上，c = a + b中的“+”也是一个函数，不过这个函数是由编译器实现的。在之前的point.cpp代码中，如果使用+将两个坐标相加，看看会有什么结果。 直接使用+将两个坐标相加。 此时编译会报错，这是因为默认的+号是不支持两个坐标相加的。可以通过重载运算符将+号重载，让它支持坐标相加。首先，增加operator+函数。然后让它成为Point类的友员函数，这样就可以直接使用p1.x，p1.y，而不是通过getX这些函数获取坐标值。 最
运算符重载的实现代码
cvhbfgh的博客
03-17 450
# include using namespace std; class Complex { friend ostream& operator public: Complex(const double real, const double image) :_real(real) , _image(image) {} Complex(const Complex
类中运算符重载
qq_24503095的博客
11-23 5169
运算符重载 运算符重载时一种形式的C++多态 1、运算符重载的格式： operator op(parameter-list); 其中，op必须时有效的C++运算符。 2、调用方式 obj = obj1 + obj2; obj = obj1.operator+(obj2); 在运算符表示法中，运算符左侧的对象是调用对象，运算符右侧的是作为参数被传递的对象。 3、重载限制 至少有一个操作上是用户定...
运算符重载（附源代码）
qq_44768163的博客
03-19 1168
文章目录运算符重载重载限制 运算符重载 重载意义 在C++预定义中，运算符的操作对象只局限于基本的内置数据类型(int、double…)，但是对于我们自定义的类型（类）是无法完成对应操作的。当我们对自定义的类型也有类似操作需求时，便需要对运算符进行不同的定义，赋予其新的功能，通过参数的类型及个数来区分，完成重载。 重载格式： <返回类型说明符> operator <运算符符号>(<参数表>) { <函数体> } 重载限制 重载运算符的基本原则： C+
【C++】运算符重载 ② ( 类内部定义云算符重载 - 成员函数 | 类外部定义运算符重载 - 全局函数 | 可重载的运算符 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-03 793
一、运算符重载本质 二、运算符重载语法 - 类内部定义云算符重载 ( 成员函数 ) 1、运算符重载函数语法说明 2、运算符重载函数调用 3、代码示例 - 运算符重载函数调用 三、运算符重载语法 - 类外部定义运算符重载 ( 全局函数 ) 1、运算符重载函数语法说明 2、运算符重载函数调用 四、可重载的运算符
C++深入教学：类、对象、继承与运算符重载
本课件详细地探讨了C++中的多个关键概念，包括类和对象的定义和使用、输入输出操作、运算符重载、继承和派生类以及指针数组等高级特性。下面将针对每个知识点进行详细说明。 1. 类和对象： C++中的“类”是创建对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

青山入墨雨如画

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

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

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

打赏作者

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

抵扣说明：

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

余额充值