C++基础-静态成员变量和静态成员函数,单例模式,this指针，常函数和常对象，友元函数

最新推荐文章于 2023-01-19 14:37:14 发布
最新推荐文章于 2023-01-19 14:37:14 发布
阅读量419 收藏
点赞数
分类专栏： # C++语言 文章标签： 单例模式 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41865866/article/details/126324966
版权

01 静态成员变量和静态成员函数

1.静态成员变量，在类内声明，类外进行初始化

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:
	Person()
	{
		//m_Age = 10;
	}

	static int m_Age;//加入static就是 静态成员变量，会共享数据
	//静态成员变量，在类内声明，类外进行初始化
};
int Person::m_Age = 0;//类外初始化实现


void test01()
{
	//1.通过对象访问属性
	Person p1;
	p1.m_Age = 10;

	Person p2;
	p2.m_Age = 20;

	cout << "p1.m_Age:" << p1.m_Age << endl;//20
	cout << "p2.m_Age:" << p2.m_Age << endl;//20
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

2.静态成员变量也是有权限的

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:

	static int m_Age;//加入static就是 静态成员变量，会共享数据
	//静态成员变量，在类内声明，类外进行初始化

	int m_A;
	//静态成员变量也是有权限的
private:
	static int m_other;

};
int Person::m_Age = 0;//类外初始化实现
int Person::m_other = 10;


void test01()
{
	//1.通过对象访问属性
	Person p1;
	p1.m_Age = 10;

	Person p2;
	p2.m_Age = 20;

	cout << "p1.m_Age:" << p1.m_Age << endl;//20
	cout << "p2.m_Age:" << p2.m_Age << endl;//20

	//2.通过类名访问属性
	cout << "通过类名访问m_Age:" << Person::m_Age << endl;
	//cout << "通过类名访问m_other:" << Person::m_other << endl;//私有权限在类外无法访问
}

int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

3.静态成员函数不可以访问普通成员变量

因普通成员变量可以别共享，所以静态成员函数不可以访问普通成员变量。
原理如下：
在这里插入图片描述

4.普通成员函数 可以访问普通成员变量，也可以访问静态成员变量

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:

	static int m_Age;//加入static就是 静态成员变量，会共享数据
	//静态成员变量，在类内声明，类外进行初始化

	int m_A;

	//静态成员函数
	//静态成员函数不可以访问 普通成员变量
	//普通成员函数 可以访问普通成员变量，也可以访问静态成员变量
	static void func()
	{
		//m_A = 10;//不可以访问
		m_Age = 10;//可以访问静态成员变量
		cout << "静态成员函数 func() 的调用" << endl;
	}

	//静态成员变量也是有权限的
	//静态成员函数也是有权限的
private:
	static int m_other;

	void func2()
	{

	}
};
int Person::m_Age = 0;//类外初始化实现
int Person::m_other = 10;


void test01()
{
	//1.通过对象访问属性
	Person p1;
	p1.m_Age = 10;

	Person p2;
	p2.m_Age = 20;

	cout << "p1.m_Age:" << p1.m_Age << endl;//20
	cout << "p2.m_Age:" << p2.m_Age << endl;//20

	//2.通过类名访问属性
	cout << "通过类名访问m_Age:" << Person::m_Age << endl;
	//cout << "通过类名访问m_other:" << Person::m_other << endl;//私有权限在类外无法访问

	//静态成员函数的调用
	p1.func();
	p2.func();
	Person::func();

	//静态成员函数也是有权限的
	//Person::func2();
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

02 单例模式案例-主席案例

构造函数优于main函数调用，static在编译阶段就构造好了，main函数是在运行阶段才调用

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//创建主席类
class ChairMan
{
private:
	//构造函数私有化
	ChairMan() {
		cout << "主席构造函数调用" << endl;
	}
public:
	static ChairMan* singleMan;
};

ChairMan* ChairMan::singleMan = new ChairMan;

//需求 单例模式 为了创建类中的对象，并且保证只有一个对象实例
void test01()
{
	/*ChairMan c1;
	ChairMan* c2 = new ChairMan;*/

	ChairMan::singleMan;
}

int main(void)
{
	cout << "main函数调用" << endl;//主席先于main的调用
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//创建主席类
class ChairMan
{
private:
	//构造函数私有化
	ChairMan() {
		cout << "主席构造函数调用" << endl;

	}
	//拷贝构造函数私有化
	ChairMan(const ChairMan& c) {}

public:

	//提供get方法访问主席
	static ChairMan* getInstance()
	{
		return singleMan;
	}

private:
	static ChairMan* singleMan;
};
ChairMan* ChairMan::singleMan = new ChairMan;


//需求 单例模式 为了创建类中的对象，并且保证只有一个对象实例
void test01()
{
	/*ChairMan c1;
	ChairMan* c2 = new ChairMan;*/

	/*ChairMan* cm1 = ChairMan::singleMan;
	ChairMan* cm2 = ChairMan::singleMan;*/

	//ChairMan::singleMan = NULL;

	ChairMan* cm1 = ChairMan::getInstance();
	ChairMan* cm2 = ChairMan::getInstance();

	if (cm1 == cm2)
	{
		cout << "cm1和cm2相同" << endl;
	}
	else
	{
		cout << "cm1和cm2不相同" << endl;
	}

	/*ChairMan* cm3 = new ChairMan(*cm1);//构造函数私有化了，不可调用默认构造函数使用值传递，导致不相同
	if (cm3 == cm2)
	{
		cout << "cm3和cm2相同" << endl;
	}
	else
	{
		cout << "cm3和cm2不相同" << endl;
	}*/
}

int main(void)
{
	//cout << "main函数调用" << endl;//主席先于main的调用
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

03 单例模式案例-打印机案例

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

class Printer
{
private:
	Printer() {//:printCount(0){
		//printCount = 0;
	}
	Printer(const Printer& p) {}

public:
	static Printer* getInstance()
	{
		return singlePrinter;
	}

	void doPrintText(string text)
	{
		cout << text << endl;
		printCount++;
	}
	int getPrintCount()
	{
		return printCount;
	}

private:
	static Printer* singlePrinter;
	static int printCount;

};
Printer* Printer::singlePrinter = new Printer;
int Printer::printCount = 0;

void test01()
{
	Printer* printer = Printer::getInstance();
	printer->doPrintText("入职报告");
	printer->doPrintText("加薪申请");
	printer->doPrintText("升级申请");
	printer->doPrintText("退休申请");
	printer->doPrintText("辞职报告");

	cout << "公司打印机使用次数： " << printer->getPrintCount() << endl;
}

int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

04 C++对象模型初探-成员变量和成员属性分开处理

1.成员变量和成员属性分开存储

在这里插入图片描述

2.空类的大小为1，每个实例的对象都有独一无二的地址

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{

};

void test01()
{
	cout << "Person 类的大小： " << sizeof(Person) << endl;
	//空类的大小为1，每个实例的对象都有独一无二的地址，char维护这个地址
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
非静态成员变量。才属于对象身上

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:
	int m_A;//非静态成员变量，属于对象身上
	void func() {}//非静态成员函数，不属于对象身上
	static int m_B;//静态成员变量，不属于对象身上
	static void func2() {};//静态成员变量，不属于对象身上
};
//结论：非静态成员变量。才属于对象身上
void test01()
{
	cout << "Person 类的大小： " << sizeof(Person) << endl;
	//空类的大小为1，每个实例的对象都有独一无二的地址，char维护这个地址
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
calss默认对齐，可以用#pragma pack(1)删除

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//#pragma pack(1)

class Person
{
public:
	int m_A;//非静态成员变量，属于对象身上
	void func() {}//非静态成员函数，不属于对象身上
	static int m_B;//静态成员变量，不属于对象身上
	static void func2() {};//静态成员变量，不属于对象身上
	double m_C;//16
};
//结论：非静态成员变量。才属于对象身上
void test01()
{
	cout << "Person 类的大小： " << sizeof(Person) << endl;
	//空类的大小为1，每个实例的对象都有独一无二的地址，char维护这个地址
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

05 this指针基本使用

1.this指针指向被调用的成员函数所属的对象

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
//#pragma pack(1)

class Person
{
public:
	int m_A;//非静态成员变量，属于对象身上
	void func() {}//非静态成员函数，不属于对象身上
	static int m_B;//静态成员变量，不属于对象身上
	static void func2() {};//静态成员变量，不属于对象身上
	double m_C;//16
};

void test02()
{
	//this指针指向被调用的成员函数所属的对象

	Person p1;
	p1.func();//编译器会默认加一个隐含指针 this指针 在这是Person* this
	//this指针永远指向当前对象

	Person p2;
	p2.func();
}

2.this可以解决命名冲突问题

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;


class Person
{
public:
	//this可以解决命名冲突问题
	Person(int age)
	{
		this->age = age;
	}

	//对比年龄
	void compareAge(Person& p)
	{
		if (this->age == p.age)
		{
			cout << "年龄相等" << endl;
		}
		else
		{
			cout << "年龄不相等" << endl;
		}
	}

	int age;
};

void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
	p1.compareAge(p2);

	cout << "p1.age = " << p1.age << endl;
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

3.*this 链式编程

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;


class Person
{
public:
	//this可以解决命名冲突问题
	Person(int age)
	{
		this->age = age;
	}

	//对比年龄
	void compareAge(Person& p)
	{
		if (this->age == p.age)
		{
			cout << "年龄相等" << endl;
		}
		else
		{
			cout << "年龄不相等" << endl;
		}
	}

	//年龄相加
	Person& plusAge(Person& p)
	{
		this->age += p.age;
		return *this;//this指向对象本体
	}

	int age;
};

void test01()
{
	Person p1(10);

	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
	p1.compareAge(p2);

	p1.plusAge(p2).plusAge(p2);//链式编程

	cout << "p1.age = " << p1.age << endl;
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

06 空指针访问成员函数

如果成员函数没有用到this,那么空指针可以直接访问
如果成员函数用到this指针，那么注意，可以加if判断，如果this为NULL就return

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

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

	void showAge()
	{
		if (this == NULL)
		{
			return;
		}
		cout << "personAge:" << personAge << endl;
	}

	int personAge;

};

void test01()
{
	Person* p1 = NULL;
	p1->personShow();
	p1->showAge();
}

int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

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

	void showAge()
	{
		if (this == NULL)
		{
			return;
		}
		cout << "personAge:" << personAge << endl;
	}

	int personAge;

};

void test01()
{
	Person* p1 = NULL;
	p1->personShow();
	p1->showAge();
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

07 常函数和常对象

常函数,不允许修改this指针指向的值.
常对象,不允许修改属性.
常对象,不可以调用普通成员函数.
常对象,可以调用常函数.

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person
{
public:

	Person()
	{
		this->m_A = 0;
		this->m_B = 0;
	}

	void showInfo() const//常函数 不允许修改this指针指向的值
	{
		//this->m_A = 10;
		this->m_B = 10;

		cout << "m_A:" << this->m_A << endl;
		cout << "m_B:" << this->m_B << endl;
	}



	int m_A;
	mutable int m_B;//就算是常函数，这个变量还是有修改的需求
};

void test01()
{
	Person p1;
	p1.showInfo();

	//常对象 不允许修改属性
	const Person p2;
	//p2.m_A = 1000;
	//常对象 不可以调用普通成员函数
	//常对象 可以调用常函数
}

int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

08 全局函数做友元函数

全局函数写到类中做声明，并且最前面写关键字friend。
友元函数的目的就是访问类中的私有成员属性。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

class Building
{
	//将全局函数变为 友元函数
	friend void goodGay(Building* building);
public:
	Building()
	{
		this->m_bedRoom = "卧室";
		this->m_SittingRoom = "客厅";
	}


	//客厅 卧室
public:
	string m_SittingRoom;

private:
	string m_bedRoom;
};

void goodGay(Building* building)
{
	cout << "好基友正在访问 " << building->m_SittingRoom << endl;
	cout << "好基友正在访问 " << building->m_bedRoom << endl;
}

//友元函数的目的就是 访问类中的私有成员属性
void test01()
{
	Building* building = new Building;
	goodGay(building);

	delete building;
}

int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

09 类做友元类

友元类注意：
1.友元关系不能被继承
2.友元关系是单向的，类A是类B的朋友，但类B不一定是类A的朋友
3.友元关系不具有传递性。类B是类A的朋友，类C是类B的朋友，但类C不一定是类A的朋友。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;

class Building
{
	//将全局函数变为 友元函数
	friend void goodGay(Building* building);
public:
	Building()
	{
		this->m_bedRoom = "卧室";
		this->m_SittingRoom = "客厅";
	}


	//客厅 卧室
public:
	string m_SittingRoom;

private:
	string m_bedRoom;
};

void goodGay(Building* building)
{
	cout << "好基友正在访问 " << building->m_SittingRoom << endl;
	cout << "好基友正在访问 " << building->m_bedRoom << endl;
}

//友元函数的目的就是 访问类中的私有成员属性
void test01()
{
	Building* building = new Building;
	goodGay(building);

	delete building;
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

10 成员函数做友元函数

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//只让visit可以作为Building的好朋友 ，visit2不可以访问私有成员属性
class Building;
class goodGay
{
public:
	goodGay();

	void visit();
	void visit2();
private:
	Building* m_building;

};
class Building
{
	//让成员函数 visit作为友元函数
	friend void goodGay::visit();
public:
	Building();

public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

void test01()
{
	goodGay gg;
	gg.visit();
}

int main(void)
{
	test01();

	system("pause");
	return EXIT_SUCCESS;
}

Building::Building()
{
	this->m_BedRoom = "卧室";
	this->m_SittingRoom = "客厅";
}

goodGay::goodGay()
{
	this->m_building = new Building;
}

void goodGay::visit()
{
	cout << "好基友正在访问 " << m_building->m_SittingRoom << endl;
	cout << "好基友正在访问 " << m_building->m_BedRoom << endl;
}

void goodGay::visit2()
{
	cout << "好基友正在访问 " << m_building->m_SittingRoom << endl;
	//cout << "好基友正在访问 " << m_building->m_BedRoom << endl;
}

在这里插入图片描述

好奇养活小猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 类中的static成员的使用及单例设计示例
ylh的博客
09-27 1528
被static修饰的成员变量，成员函数，单例设计模式封装图片资源
C++：静态成员及单例模式
weixin_53762042的博客
07-28 272
先考虑一种情况，对一个已知对象进行拷贝，编译系统会自动调用一种构造函数——拷贝构造函数，如果用户未定义拷贝构造函数，则会调用默认拷贝构造函数。 先看一个例子，有一个学生类，数据成员时学生的人数和名字： #include using namespace std; class Student { private: int num; char *name; public: Student(); ~Student(); }; Student::Student() { name = new char(20)
C++静态成员与单例模式
weixin_56067923的博客
01-19 608
C++静态成员与单例模式
简单讲解C++中的静态成员与类
weixin_48322392的博客
09-28 423
被static修饰过的成员变量和成员函数都称为静态成员只能实例化出一个类对象。
c++小心得之1： 静态成员变量、静态成员函数和单例模式
asbhunan129的博客
01-02 1243
今天在看单例模式时，看到了有静态成员变量和静态成员函数的使用，发现不太熟悉，特意去熟悉了下，现贴些自己的心得； 拿单例模式代码来说明；             静态数据成员是类的成员，而不是对象的成员，所有该类对象都共用该数据成员，可以实现同类对象之间进行数据共享。             静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化。 　　1、静态数据成员在定义或声明时前...
C++运算符重载 成员函数与友元函数详解
09-05
在成员函数中，我们可以通过`this`指针访问对象，而在友元函数中，我们需要直接传递对象的引用。 在选择使用哪种方式时，需要考虑运算符的语义以及它是否需要访问对象的私有或保护成员。如果运算符应该“作用于”...
C++ 友元函数的函数指针
12-30
　讲友元之前先讲普通的成员函数的函数指针 　<code class=sourceCode>class Std_interface { 　public: 　virtual void suspend() = 0; 　}; 　// define the pointer of function 　typedef void (Std_...
简要介绍C++编程中的友元函数和友元类
09-03
友元函数不是类的成员，所以它不能使用 `this` 指针，必须通过对象来访问成员。例如，`display` 函数通过参数传递 `Student` 对象引用来访问其私有成员。如果不声明 `display` 为友元函数，那么尝试访问私有成员会...
C++实验六类和对象-对象传递与静态成员
最新发布
03-14
### C++实验六类和对象-对象传递与静态成员 #### 实验目的 1. **理解静态成员（静态数据成员、静态成员函数）的作用与使用**：了解如何使用静态成员来共享数据或方法，理解其在类中的特殊作用。 2. **理解友元...
关于C++中的友元函数的一些总结
09-05
- **`this`指针**：成员函数有`this`指针，用于访问当前对象的成员，而友元函数没有`this`指针，需要通过对象参数来访问成员。 - **继承**：成员函数可以被子类继承，而友元函数不会自动继承到子类，需要在子类中...
38.static
augfun的博客
08-11 195
静态成员 不管这个类创建了多少个对象，静态成员只有一个拷贝，这个拷贝被所有属于这个类的对象共享，静态变量，是在编译阶段就分配空间，对象还没有创建时，就已经分配空间 静态成员变量必须在类中声明，在类外定义。 静态数据成员不属于某个对象，在为对象分配空间中不包括静态成员所占空间。 静态数据成员可以通过类名或者对象名来引用。 编译阶段分配内存 所有对象共享数据 通过对象访问、通过类名访问 有权限控...
c++中静态函数与动态函数的区别以及与单例模式的关系
ZGT的博客
07-16 1452
参考: https://zhuanlan.zhihu.com/p/37469260 https://www.cnblogs.com/zxh1210603696/p/4157294.html https://blog.csdn.net/Wu_qz/article/details/81044823 static： 静态数据成员 1、在类内数据成员前加上 static 关键字，即为静态...
【c/c++】 宏定义define和const用法详解
All_In_gzx_cc的博客
01-07 3796
在写程序时经常会碰到这样一个问题，我们需要重复写很多相同的代码，并且这些代码结构相同。总是想自己把这段代码封装一下然后直接进行调用，但是如果这段代码逻辑并不复杂，并且代码量也不大，不适合进行封装，那么我们就会想到c/c++中的关键字define。其实明智的你，遇到上面的这些情况估计还会想到另一个东西----template，后面我们也会说一下两者的却别。今天自己看了一下c++ define的相关知识，做个记录。 1.什么是define 宏定义，简单的理解就是替换，其实这也是本质。如果熟悉g++编译过程的话，
类内静态成员变量的定义和声明
SavenNeer的博客
02-24 4307
在《Effective C++（第三版）》条款2中，作者建议“使用编译器替代预处理器”。其中，在替代#define时的第二方案中提到了类内静态成员变量的使用方法。 一般情况下，C++要求变量的使用必须遵循先定义后使用，对于仅仅被声明而从未被定义的变量，编译器不予通过。但是这种情况在C++类内静态变量的定义中存在特殊情况，也就是只声明、不定义、即使用。 1、对于一般的类内专属常量，遵循类内声明，类外定义。该类内专属常量最好使用static const修饰，对于不需要修改指向对象的指针也最好定义成static
类的static成员咋用？和普通成员变量之间怎么访问？
qq_38915078的博客
01-15 3680
1、记录原因 之前一直捋不清普通成员和静态成员之间怎么访问，经常忘记，最近学习设计模式的单例模式时，顺便重温《C++ Primer》static关键字，有了一些新的理解，可能不完全正确，如果有误，望读者提出。 2、C++ primer上的介绍 我们通过再成员声明之前 3、重点 4、总结 ...
static成员函数不可以直接访问成员变量和普通函数可以访问静态变量以及内存分配详解
武凯的博客
03-24 5135
1.静态变量空间分配问题 #include<iostream> using namespace std; class Person{ public: static int hand; static void hitPeople(); }; int main() { cout<<'1'<<endl; } 结果: #include<iostream> using namespace std; class Per
C++中静态成员函数访问成员变量问题
#+!
03-13 6054
C++会区分两种类型的成员函数：静态成员函数和非静态成员函数。这两者之间的一个重大区别是，静态成员函数不接受隐含的this自变量。所以，它就无法访问自己类的非静态成员。 左例中分别声明了成员函数void add(),成员变量int a,和静态成员函数 static void staticfunc(),静态成员变量 static int sa. 在staticfunc()的定
静态类成员函数无法访问普通的成员变量
CppPlayer
05-17 2419
class A { int m_i; public: static void f() { m_i=666; //这是非法的，这个等价于this->m_i=666,而静态方法没有this } static void f(A&a) { a.m_i=666; //这样就可以 } };静态成员函数不属于任何一个类
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值