【C++学习】类和对象（下）

最新推荐文章于 2024-11-02 20:39:05 发布
最新推荐文章于 2024-11-02 20:39:05 发布
阅读量852 收藏 3
点赞数 3
分类专栏： C++ 文章标签： c++ 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44906102/article/details/130656408
版权

目录

一、再谈构造函数

1.1 构造函数体赋值

1.2 初始化列表

1.3 初始化列表的注意事项

1.4 explicit关键字

 二、static成员（静态成员变量 & 静态成员函数）

2.1 概念：

 2.2 特征

三、友元 

3.1 友元函数

3.2 友元类

四、内部类 

五、匿名对象 

六、拷贝对象时的部分编译器优化情况

一、再谈构造函数

1.1 构造函数体赋值

        在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
	Date(int year = 2022, int month = 11, int day = 27)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

        虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。 

1.2 初始化列表

  • 实际上，初始化列表的知识属于构造函数知识的一部分。顾名思义，初始化列表就是为了解决对象初始化问题而存在的。
  • 初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

我们可以将上面的代码改成如下形式进行初始化。

class Date
{
public:
	Date(int year = 2022, int month = 11, int day = 27)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

1.3 初始化列表的注意事项

  •  每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次，多次初始化会报错）
class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		:_year(year)
		, _month(month)
		, _day(day)
		, _month(month) //初始化列表多次初始化，err
	{}
 
private:
	int _year;
	int _month;
	int _day;
};

        编译器也允许构造函数赋初值和初始化列表初始化混用，混用时初始化列表初始化和构造函数赋初值不冲突

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 11, int day = 27)
		: _year(year) //两者不冲突
		, _month(month)
	{
		_day = day;
		_year = 2023;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
  •  类中包含以下成员，必须放在初始化列表位置进行初始化：

1、引用成员变量

2、const成员变量

3、自定义类型成员(且该类没有默认构造函数时)

        const成员变量、引用成员变量、没有默认构造函数的自定义类型成员变量必须在初始化列表内初始化的原因：

①初始化列表是对象的成员变量定义的地方。

②对象的内置类型成员变量在初始化列表定义时没有要求必须初始化，因此既可以在初始化列表进行初始化，也可以在构造函数体内初始化。

③而const成员变量、引用成员变量、没有默认构造函数的自定义类型成员变量，不能先定义再初始化，它们在初始化列表内定义，并且必须在定义时就初始化，因此必须在初始化列表内初始化。

引用成员变量要在初始化列表初始化 

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 11, int day = 27)
		: _year(year) 
		, _month(month)
		,_ref(year)//引用成员变量要在初始化列表初始化
	{
		_day = day;
		//_ref = year; //引用成员变量不能在函数体内初始化
	}
 
private:
	int _year;
	int _month;
	int _day;
 
	int& _ref;
};

 const成员变量必须使用初始化列表进行初始化 

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 11, int day = 27)
		: _year(year) 
		, _month(month)
		, _n(2) //const成员变量必须使用初始化列表进行初始化
	{
		_day = day;
		//_n = 2; //const成员变量不能在函数体内初始化
	}
 
private:
	int _year;
	int _month;
	int _day;
 
	const int _n = 1;
};

 没有默认构造函数的自定义类型成员变量，必须在初始化列表进行初始化

#include <iostream>
using namespace std;
 
class A
{
public:
	
	//默认构造函数是不用传参就可以调用的构造函数，有3种：
	//1.无参默认构造函数
	//2.带参全缺省的默认构造函数（每个变量都有赋值）
	//3.我们不写，编译器自动生成的默认构造函数
 
	A(int x)//不属于以上任何一种，所以A类的对象没有默认构造函数
	{
		cout << "A(int x)" << endl;
		_x = x;
	}
 
private:
	int _x;
};
 
class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 11, int day = 27)
		: _year(year) 
		, _month(month)
		, _a(20)//没有默认构造函数的自定义类型成员变量必须在初始化列表进行初始化
	{
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
 
	A _a;
};
  •  尽量使用初始化列表初始化

 因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	Date(int day)
	{}
private:
	int _day;
	Time _t;
};
int main()
{
	Date d(1);
}

  • 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

也就是说，类中（private：）声明变量的顺序是什么，初始化的顺序就是什么

1.4 explicit关键字

        构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

我们先看一下类型转换，可以做到什么：

void Test()
{
	Date d1(2022);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2023;
}

        将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用。

class Date
{
public:
	// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
    // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
    // explicit Date(int year)
	Date(int year)
		:_year(year)
	{}
 
	/*
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
   有类型转换作用
	// explicit修饰构造函数，禁止类型转换
	explicit Date(int year, int month = 1, int day = 1)
	: _year(year)
	, _month(month)
	, _day(day)
	{}
	*/
 
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

 二、static成员（静态成员变量 & 静态成员函数）

2.1 概念：

        声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

面试题：实现一个类，计算程序中创造出了多少个类对象。

class A
{
public:
    A() { ++_scount; }
    A(const A& t) { ++_scount; }
    ~A() { --_scount; }
    static int GetACount() { return _scount; }
private:
    static int _scount;
};

int A::_scount = 0;

void TestA()
{
    cout << A::GetACount() << endl;
    A a1, a2;
    A a3(a1);
    cout << A::GetCount() << endl;
}

 2.2 特征

  1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
  2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
  5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

        第1点很好理解，就是同一个类的不同对象都可以使用同一个静态成员，（类未被清理之前）静态成员使用完之后不会销毁；第2、3、4点我们直接通过代码来理解；第5点很简单，这里就不再赘述了；

class A
{
public:
	A(int a = 0)//构造
		:_a(a)
	{
		++N;
	}
 
	A(const A& aa)//拷贝构造
		:_a(aa._a)
	{
		++N;
	}
 
	// 静态成员函数没有this指针，只能访问静态成员（特征第4点）
	static int GetN()
	{
		return N;
	}
 
private:
	int _a;
 
	static int N; // 声明
};
 
// 生命周期是全局的，作用域受类域限制，也就是说N的访问受类的限制
int A::N = 0;  // 类外，定义初始化（特征第2点）
 
void F1(A aa)
{}
 
A F2()
{
	A aa;
	return aa;//返回不是直接返回，需要调用一次拷贝构造，再把构造值返回
}
 
 
int main()
{
	//静态变量的返回方法
/*	A aa1(1);
	A aa2 = 2;
 
	A aa3 = aa1;
 
	cout << aa1.GetN() << endl;//访问静态成员函数（特征第3点）
 
	F1(aa1);
	cout << aa1.GetN() << endl;
*/
 
	//类的静态变量不能在main()直接修改
	// --N;
 
	F2();
 
	//静态函数的返回方法
	//这里有一个访问静态成员函数的优化技巧
	//优化前
	//A aa4;
	//cout << aa4.GetN() << endl;
 
	//优化后
	cout << A::GetN() << endl;
 
 
	return 0;
}

【问题】

1. 静态成员函数可以调用非静态成员函数吗？                答：不可以

2. 非静态成员函数可以调用类的静态成员函数吗？         答：可以

三、友元 

        友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。友元分为：友元函数和友元类。

3.1 友元函数

问题：现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。

        因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
 
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout)
{
	_cout << _year << "-" << _month << "-" << _day << endl;
	return _cout;
}
private:
	int _year;
	int _month;
	int _day;
};

        友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加 friend 关键字。

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

 【说明】

  • 友元函数可访问类的私有和保护成员，但不是类的成员函数
  • 友元函数不能用const修饰
  • 友元函数可以在类定义的任何地方声明，不受类访问限定符限制（可访问private）
  • 一个函数可以是多个类的友元函数
  • 友元函数的调用与普通函数的调用原理相同 

3.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

1、友元 关系是单向的，不具有交换性。
        比如下述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

2、友元关系不能传递如果C是B的友元。
        B是A的友元，则不能说明C时A的友元。

3、友元关系不能继承。

class Time
{
	friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
	中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}
 
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
 
	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
 
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

四、内部类 

概念：

        如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

注意：

        内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访
问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

  1.  内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系。 
class A
{
public:
	class B // B天生就是A的友元
	{
	public:
		void function(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	};
private:
	static int k;
	int h;
};
int A::k = 1;
 
int main()
{
	A::B b;//使用上要注意
	b.function(A());
 
	return 0;
}

五、匿名对象 

        下面我们一起来看一段长代码来理解匿名对象的含义和作用，我们可以直接从 main() 看起。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()//析构函数
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1;
	// 不能像下面这样定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
	//A aa1();
	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，下一行他就会自动调用析构函数
	A();
	A aa2(2);//在（）中加上数值，就可以让编译器识别出它是对象定义
 
	// 匿名对象在这样场景下就很好用 - 两行代码优化成一行直接构造
	//Solution aa3;
	//aa3.Sum_Solution(10);
	Solution().Sum_Solution(10);
	return 0;
}

六、拷贝对象时的部分编译器优化情况

        在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。 

class A
{
public:
	A(int a = 0)//构造函数
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)//拷贝构造
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)//运算符重载
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()//析构函数
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
void f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}
int main()
{
	// 传值传参
	A aa1;
	f1(aa1);
	cout << endl;
	// 传值返回
	f2();
	cout << endl;
 
	// 隐式类型，连续构造+拷贝构造->优化为直接构造
	f1(1);
 
	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
	f1(A(2));
	cout << endl;
 
	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
	A aa2 = f2();
	cout << endl;
 
	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
	aa1 = f2();
	cout << endl;
 
	return 0;
}

        类是对某一实体(对象)来进行描述的，描述该对象具有哪些属性哪些方法，描述完成后九形成了一种新的自定义类型，采用该自定义类型就可以实例化具体的对象

Cassooo_
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
C++类和对象超详细
C/C++学习之旅
02-09 3370
本文对C++类和对象的知识进行了详细的介绍,构造析构拷贝构造等成员函数,以及友元,内部类,等等
c++ — 类和对象
水澹澹兮生烟
07-10 3140
我们在学习C语言时知道，C语言是面向过程的语言，他关系的是是完成事情的过程，以函数进行驱动，在对于比较规模的程序来说，我们可以直接编写出一个mian'xiang'guo'cehng
C++类和对象详解
weixin_43730061的博客
03-25 7300
类与对象上篇： 主要内容： 1.类和对象的区别。 2.类的定义。 3.类的访问限定符和封装 4.类的作用域 5.类的实例化（用类类型创建对象） 6.计算类对象的大小 7.this指针 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 1.类和对象的区别： 类是抽象的，不占用内...
C++_类和对象
Mr___Blue的博客
04-18 2143
快速帮助了解学习C++中类和对象的基本概念
C++类对象进行排序
taoxing
08-29 5128
写在前面 C++类对象按照某一个属性进行排序很早以前就学习过，但是时间久了开始有点遗忘了，现在就把最常用的一共方法进行以下总结。 一. 二.
【C++】(二) 类和对象的定义与使用
Explore_Zhou
06-11 3605
  建议先看完上面那篇博客。这篇博客主要讲述C++中类和对象的定义与使用。  先介绍一些概念，建立理论印象。  所谓对象，其实就是用来描述客观事物的一个实体，比如一辆汽车就是一个对象。描述一个对象时，一般会从它的属性和行为两方面来展开，其中，属性可以认为是对象的静态特征，一些数据；而行为可以认为是对象的动态特征，对应的操作等。   而类，是具有相同属性和服务的一组对象的集合，它是属于该类的全部对象的一个抽象描述，因此同样具有属性和行为两部分，但这里更多的是抽象的概念。   类和对象的关系犹如模具和铸件之间的
【C++学习】类与对象（一）——类的定义与对象实例
m0_74301063的博客
03-28 2341
类与对象基础概念的说明与运用
C++学习——类和对象
流楚丶格念的博客
02-12 3752
一、类和对象基本知识： 1、类的访问控制有哪些？ 公有成员：以关键字public指明。 私有成员：以关键字private指明。 保护成员：以关键字protected指明。 2、拷贝构造函数的作用是什么？ 用一个已经存在的对象初始化本类的新对象。 3、友元函数和友元类的作用是什么？ 友元提供了不同类或对象的成员函数之间、类的成员函数与一般函数之间进行 数据共享的机制。对于一个类，可以利用关键字fri...
C++类和对象——(5)定义对象数组
一个正在学习C/C++的博主
12-03 1932
类和对象——(5)定义对象数组
C++ STL学习与面向对象编程实践
09-14
内容概要：本文为《C++ 入门与 STL 学习》的系列笔记汇编，包含了 C++ 基础、STL（Standard Template Library）的各种容器与算法的学习，及类的设计、继承、多态等面向对象特性的讲解与应用。重点涵盖了 C++ 中容器...
【C++】类和对象
iluo12的博客
04-24 2282
C++类和对象
【C/C++学习编程】C++用new和不用new创建类对象区别
C语言C++学习俱乐部：765860056
10-27 1963
前言：起初刚学C++时，很不习惯用new，后来看老外的程序，发现几乎都是使用new，想一想区别也不是太大，但是在大一点的项目设计中，有时候不使用new的确会带来很多问题。 当然这都是跟new的用法有关的。new创建类对象，使用完后需使用delete删除，跟申请内存类似。所以，new有时候又不太适合，比如在频繁调用场合，使用局部new类对象就不是个好选择，使用全局类对象或一个经过初始化的全局类指针似乎更加高效。 一、new创建类对象与不new区别 下面是自己总结的一些关于new创建类对象特..
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 453
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 183
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 30
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2201
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 869
书生浦语大模型实战营第四期：Linux前置基础
每日OJ题_牛客_排序子序列_模拟_C++_Java
最新发布
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 283
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
C++学习笔记：类和对象基础应用探索
"这篇文档是关于C++学习的笔记，主要介绍了类和对象在C++中的简单应用，并提供了课程概述、C++的起源与发展、行业地位以及应用领域的相关信息。" 在C++编程语言中，类和对象是核心概念，它们是实现面向对象程序设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cassooo_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值