C++面向对象之“类“

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量312 收藏 2
点赞数 3
分类专栏： C++面向对象 文章标签： c++ 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44989173/article/details/116768914
版权

C++面向对象之"类"

上一节讲了头文件。头文件
本节正式进入面向对象的编程，类。

  • 面向过程: 根据程序执行的先后顺序，来设计所有细节
    缺点：开发大型项目时，会导致难把控所有的细节。
  • 面向对象: 一种全新的开发方式。

文章目录

类的基础

  • 最重要的一个概念:“类” class
    类是一种特殊的“数据结构"，不是一个具体的数据。
    和基本的数据类型不同 (char/int/float)
    在实现类的时候一般把类与类的方法声明放到.h文件中，它的实现放在一个.cpp文件中。

  • 使用class 类名{
    public:
    ​ 成员或方法
    private:
    ​ 成员或方法
    };

  • 类的设计:
    在这里插入图片描述

  • 此处定义一个 "dog类"

    #include <iostream>
#include <string>

using namespace std;

//定义类 
class Dog{
public://公有的
	void eat(); //吃 
	void sleep(); //睡	
	void play(); //玩 
	
	int getWeight(); //获取体重 
	string getName();	
		
private://私有的 无法被内部直接访问 
	 int Weight;//体重 
	 string name; //名字 
};

//实现方法
//成员函数前面要加Dog::表明该方法是类Dog的方法 
void Dog::eat(){
	cout << "吃肉" << endl; 
}

void Dog::sleep(){
	cout << "睡觉" << endl; 
}

void Dog::play(){
	cout << "玩" << endl; 
}

//通过两个内部public方法访问private成员 
int Dog::getWeight(){
	return Weight;
}

string Dog::getName(){
	return name;
}

int main(){
    //定义一个类的对象
	Dog dog;
    //失败，无法访问private成员
    //dog.name;
    //通过public方法访问私有成员
    dog.getName();
    
	return 0;
}

    此处定义一个Dog类，有类的public成员函数，有private成员。

  • 使用类中的成员需要类名.方法或者成员调用

  • 注意: private成员对外部无法访问，例如上面main函数中的dog.name失败！
    特点：安全，无法在外部被修改，只能通过内部方法修改。

  • 将private改成public可以让数据变得可以访问，但是不建议这么做，会降低安全性

类的默认构造函数

  • 在创建对象时初始化里面的数据成员就需要构造函数，不然就没有初始化。

  • 构造函数可以定义很多种构造函数

  • 在创建对象时，自动调用构造函数。

    #include <iostream>
#include <string>

using namespace std;

//定义类 
class Dog{
public://公有的
    //默认构造函数不定义会自动调用默认生成的
	Dog();
    //自定义的构造函数
    Dog(const char* name, int weight);
    
	void eat(); //吃 
	void sleep(); //睡	
	void play(); //玩 
	
	int getWeight(); //获取体重 
	string getName();	
		
private://私有的 无法被内部直接访问 
	 int Weight;//体重 
	 string name; //名字 
};

//实现方法
//默认构造函数
Dog::Dog(){
    
}

Dog::Dog(const char* _name, int _weight){
	this->name = _name;
	this->Weight = _weight; 
}
 
//成员函数前面要加Dog::表明该方法是类Dog的方法 
void Dog::eat(){
	cout << "吃肉" << endl; 
}

void Dog::sleep(){
	cout << "睡觉" << endl; 
}

void Dog::play(){
	cout << "玩" << endl; 
}

//通过两个内部public方法访问private成员 
int Dog::getWeight(){
	return Weight;
}

string Dog::getName(){
	return name;
}

int main(){
    //定义一个类的对象
	Dog dog("旺财", 20);
    //失败，无法访问private成员
    //dog.name;
    //通过public方法访问私有成员
    dog.getName();
    
	return 0;
}

    this表示一个指针，代表了调用该方法的对象，比如Dog dog("旺财", 20);中对象dog调用构造函数Dog(const char* _name, int _weight)此时this->name即为对象本身的name成员。

  • 第一个构造函数Dog::Dog();为默认的构造函数，可以缺省，第二个Dog::Dog(const char* _name, int _weight)为人工合成的默认构造函数。

类的拷贝构造函数

  • 拷贝构造函数就是相当于一种复制。自己不定义时，会自动生成默认的拷贝构造函数，具体的使用如下:

    #include <iostream>
#include <string>

using namespace std;

//定义类 
class Dog{
public://公有的
    //默认构造函数不定义会自动调用默认生成的
	Dog();
    //自定义的构造函数
    Dog(const char* name, int weight);
    
	void eat(); //吃 
	void sleep(); //睡	
	void play(); //玩 
	
	int getWeight(); //获取体重 
	string getName();	
		
private://私有的 无法被内部直接访问 
	 int Weight;//体重 
	 string name; //名字 
};

//实现方法
//默认构造函数
Dog::Dog(){
    
}

Dog::Dog(const char* _name, int _weight){
	this->name = _name;
	this->Weight = _weight; 
}
 
//成员函数前面要加Dog::表明该方法是类Dog的方法 
void Dog::eat(){
	cout << "吃肉" << endl; 
}

void Dog::sleep(){
	cout << "睡觉" << endl; 
}

void Dog::play(){
	cout << "玩" << endl; 
}

//通过两个内部public方法访问private成员 
int Dog::getWeight(){
	return Weight;
}

string Dog::getName(){
	return name;
}

int main(){
    //定义一个类的对象并调用自定义的默认构造函数
	Dog dog("旺财", 20);
    //失败，无法访问private成员
    //dog.name;
    //通过public方法访问私有成员
    cout << "dog的名字是:" << dog.getName() << endl;
    
    //下面两种都会调用拷贝构造函数
    Dog dog1 = dog;
    Dog dog2(dog);
    
    cout << "dog1的名字是:" << dog.getName() << endl;
    cout << "dog2的名字是:" << dog.getName() << endl;
	return 0;
}

    输出结果:

    dog的名字是:旺财
dog1的名字是:旺财
dog2的名字是:旺财

    这里虽然没有定义拷贝构造函数，但是系统自动生成了拷贝构造函数并且调用。

    缺点: 默认拷贝函数只是一种"浅拷贝"而非"深拷贝"。

    "深浅"拷贝

    为了让大家理解浅拷贝和深拷贝的区别，这里举个栗子:(暂时不主动释放new申请的空间)

    #include <iostream>
#include <string.h>

using namespace std;

//为了方便，方法在类中实现
class Test{
public:
	//默认构造函数
	Test(const char* _str = "测试"){
    	//包含一个结束符
    	str = new char[strlen(_str) + 1];
    	//拷贝_str字符串到str中
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

	//定义一个改变str成员的方法
	void changeStr(const char* _str){
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

	//定义一个获取str的方法
	char* getStr(){
    	return str;
	}

private:
	//字符串
	char* str;
};

int main(){
	//定义两个对象
	Test t1("测试1");
	//将t1拷贝到t2
	Test t2(t1);

	cout << "改变t2字符串前t1字符串为:" << t1.getStr() << endl;
	//改变t2的字符串，并获取t1的字符串
	t2.changeStr("测试2");
	cout << "改变t2字符串后t1字符串为:" << t1.getStr() << endl;

	return 0;
}

    输出结果:

    改变t2字符串后t1字符串为:测试1
改变t2字符串后t1字符串为:测试2

    此处由于"浅"拷贝的原因，改变t2导致t1跟着一起改变。具体解释就浅拷贝只是值的复制，所以拷贝后t2的str成员指向的内存空间和t1的str成员指向的内存空间是同一块内存空间，改变其中一个的值，另外一个会跟着变。
    所以使用系统默认的拷贝构造函数有致命的缺陷!

  • 使用 自定义的拷贝构造函数("深"拷贝) 来规避这种缺陷。

    #include <iostream>
#include <string.h>

using namespace std;

//为了方便，方法在类中实现
class Test{
public:
	//默认构造函数
	Test(const char* _str = "测试"){
    	//包含一个结束符
    	str = new char[strlen(_str) + 1];
    	//拷贝_str字符串到str中
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

    //定义拷贝构造函数
    Test(const Test& other){
        if(other.str){
            this->str = new char[strlen(other.str) + 1];
            strcpy_s(this->str, strlen(other.str) + 1, other.str);
        }
    }
    
	//定义一个改变str成员的方法
	void changeStr(const char* _str){
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

	//定义一个获取str的方法
	char* getStr(){
    	return str;
	}

private:
	//字符串
	char* str;
};

int main(){
	//定义两个对象
	Test t1("测试1");
	//将t1拷贝到t2
	Test t2(t1);

	cout << "改变t2字符串前t1字符串为:" << t1.getStr() << endl;
    cout << "改变t2字符串前t2字符串为:" << t2.getStr() << endl;
	//改变t2的字符串，并获取t1的字符串
	t2.changeStr("测试2");
	cout << "改变t2字符串后t1字符串为:" << t1.getStr() << endl;
	cout << "改变t2字符串后t2字符串为:" << t2.getStr() << endl;
	return 0;
}

    输出结果:

    改变t2字符串前t1字符串为:测试1
改变t2字符串前t2字符串为:测试1
改变t2字符串后t1字符串为:测试1
改变t2字符串后t2字符串为:测试2

    这里成功采用深拷贝规避了浅拷贝带来的问题。

  • 注意赋值构造函数(特殊的拷贝构造函数)也是浅拷贝。

    #include <iostream>
#include <string.h>

using namespace std;

//为了方便，方法在类中实现
class Test{
public:
	//默认构造函数
	Test(const char* _str = "测试"){
    	//包含一个结束符
    	str = new char[strlen(_str) + 1];
    	//拷贝_str字符串到str中
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

	//定义一个改变str成员的方法
	void changeStr(const char* _str){
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

	//定义一个获取str的方法
	char* getStr(){
    	return str;
	}

private:
	//字符串
	char* str;
};

int main(){
	//定义两个对象
	Test t1("测试1");
	//将t1赋值给t2
	Test t2 = t1;

	cout << "改变t2字符串前t1字符串为:" << t1.getStr() << endl;
	//改变t2的字符串，并获取t1的字符串
	t2.changeStr("测试2");
	cout << "改变t2字符串后t1字符串为:" << t1.getStr() << endl;

	return 0;
}

    输出结果:

    改变t2字符串后t1字符串为:测试1
改变t2字符串后t1字符串为:测试2

    这里也同要是浅拷贝，一个好的类，应该也同时有赋值构造函数来避免浅拷贝(实质上为一个=运算符的重载)。

    #include <iostream>
#include <string.h>

using namespace std;

//为了方便，方法在类中实现
class Test{
public:
	//默认构造函数
	Test(const char* _str = "测试"){
    	//包含一个结束符
    	str = new char[strlen(_str) + 1];
    	//拷贝_str字符串到str中
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

    //定义拷贝构造函数
    Test(const Test& other){
        this->str = new char[strlen(other.str) + 1];
        strcpy_s(this->str, strlen(other.str) + 1, other.str);
    }
    
    //定义赋值构造函数
	Test& operator=(const Test& other){
		if(this == &other)
			return *this;
		
		if(other.str){
			this->str = new char[strlen(other.str) + 1];
		strcpy_s(this->str, strlen(other.str) + 1, other.str);
		}
		return *this;
	}
    
	//定义一个改变str成员的方法
	void changeStr(const char* _str){
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

	//定义一个获取str的方法
	char* getStr(){
    	return str;
	}

private:
	//字符串
	char* str;
};

int main(){
	//定义两个对象
	Test t1("测试1");
	//将t1拷贝到t2
	Test t2 = t1;

	cout << "改变t2字符串前t1字符串为:" << t1.getStr() << endl;
    cout << "改变t2字符串前t2字符串为:" << t2.getStr() << endl;
	//改变t2的字符串，并获取t1的字符串
	t2.changeStr("测试2");
	cout << "改变t2字符串后t1字符串为:" << t1.getStr() << endl;
	cout << "改变t2字符串后t2字符串为:" << t2.getStr() << endl;
	return 0;
}

    输出结果:

    改变t2字符串前t1字符串为:测试1
改变t2字符串前t2字符串为:测试1
改变t2字符串后t1字符串为:测试1
改变t2字符串后t2字符串为:测试2

    这里重写了等号运算符，让其能够接受类型为Test的参数，等效于t2 =(t1);

    这里就把浅拷贝变成了深拷贝。避免了一些特殊情况。

类的析构函数

  • 析构函数和构造函数相对，用来删除类的函数。
    默认情况下也会自动生成。定义, 使用~类名()来定义。
    缺陷，它不会自动释放类的对象申请的内存空间。

    #include <iostream>
#include <string.h>

using namespace std;

//为了方便，方法在类中实现
class Test{
public:
	//默认构造函数
	Test(const char* _str = "测试"){
    	//包含一个结束符
    	str = new char[strlen(_str) + 1];
    	//拷贝_str字符串到str中
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

    //定义拷贝构造函数
    Test(const Test& other){
        this->str = new char[strlen(other.str) + 1];
        strcpy_s(this->str, strlen(other.str) + 1, other.str);
    }
    
    //定义赋值构造函数
	Test& operator=(const Test& other){
		if(this == &other)
			return *this;
		
		if(other.str){
			this->str = new char[strlen(other.str) + 1];
		strcpy_s(this->str, strlen(other.str) + 1, other.str);
		}
		return *this;
	}
    
    //默认析构函数
    ~Test(){
        cout << str <<"调用析构函数" << endl;
    }
    
	//定义一个改变str成员的方法
	void changeStr(const char* _str){
    	strcpy_s(str, strlen(_str) + 1, _str);
	}

	//定义一个获取str的方法
	char* getStr(){
    	return str;
	}

private:
	//字符串
	char* str;
};

int main(){
    //定义一个指针指向t2的str的内存空间
    char* point = NULL;
    
	//定义两个对象
	Test t1("测试1");
    
	//t2在大括号结束，自动调用析构函数
    {
        Test t2("测试2");
        point = t2.getStr();
    }
    
    //访问t2.str的内存空间，此时
    cout << "point的值:" << point << endl;
    
	return 0;
}

    输出结果:

    测试2调用析构函数
point的值:测试2
测试1调用析构函数

    这里即使是t2被析构了，仍然能够访问t2.str的内存空间，**可见析构函数不会把对象中分配好的空间给释放掉。**这会导致非常严重的后果——内存泄漏！！！

  • 改进：改进析构函数，使其能够主动在对象的生命周期结束时释放掉已经分配的空间。
    这里为了测试，拷贝构造函数采用浅拷贝方式。

    #include <iostream>
#include <string.h>

using namespace std;

//为了方便，方法在类中实现
class Test {
public:
    //默认构造函数
    Test(const char* _str) {
        //包含一个结束符
        str = new char[strlen(_str) + 1];
        //拷贝_str字符串到str中
        strcpy_s(str, strlen(_str) + 1, _str);
    }

    //默认析构函数
    ~Test() {
        if (str) delete[] str;
        cout << str << "调用析构函数" << endl;
        str = NULL;
    }

    //定义一个改变str成员的方法
    void changeStr(const char* _str) {
        strcpy_s(str, strlen(_str) + 1, _str);
    }

    //定义一个获取str的方法
    char* getStr() {
        return str;
    }

private:
    //字符串
    char* str;
};

int main() {

    //定义两个对象
    Test t1;
    //t2在大括号结束，自动调用析构函数
    {
        Test t2("测试2");
        t1 = t2;
    }

    //访问t2.str的内存空间，此时
    cout << "t1.str的值:" << t1.getStr() << endl;

    return 0;
}

    输出结果：一些奇怪的中午字符，乱码。所以这里成功使用析构函数释放掉了对象申请的空间。

本节介绍了类的基础，下节我们我们介绍类的函数成员。

point->もも
关注
专栏目录
C++之面向对象
weixin_45155703的博客
03-24 4992
面向对象的三大特性：封装、继承、多态。 首先我们先介绍一下 面向对象的建立： class 类名{ //类里面包含 属性和行为 //属性和行为可以分成三种状态：public protected private; //属性就是定义数值、行为就是函数。 //如果没有定义权限，默认为private // public: int a; int b; void fun(){ } }; C++认为万物皆可对象，对象上有其属性和行为。 封装 封装的意义：将属性和行为作为一个整体，表现生活中的事物，将
浅谈C++的面向对象
qq_46046431的博客
05-28 3364
文章目录前言如何理解C++面向对象编程封装继承多态拓展：虚函数的一点小规则总结 前言 注：我的笔记风格，可能不会特别官方，不会晦涩难懂，而是以一个初学者能看懂的方式把知识呈现出来，用最简单的语言把抽象的概念表达出来～ 经常谈到面向对象这四个字，那么下面以C++为例，谈一下我对面向对象的理解，请往下看～ 如何理解C++面向对象编程 看以下三点： 1.c++面向对象编程就是把一切事物都变成一个个对象，用属性和方法来描述对象的信息，比如定义一个猫对象，猫的眼睛、毛发、嘴巴就可以定义为猫对象的属性，猫的叫声
实验三 C++ 面向对象初步 设计point类
Wood_Du的博客
08-29 5143
2.1 设计 Point 类 （1）问题描述计算机的显示屏的坐标系是这样的，左上角的坐标为(0,0)，如下图所示。                                            定义计算机显示屏上的点 Point 类。该类具有两个私有数据成员 x、y， 分别表示该点的横坐标、纵坐标。类的声明如下： class Point { public: /
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 66万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
C++面向对象之类complex详解
qq_40319799的博客
02-25 7785
类complex可作为入门C++面向对象的经典类。complex的原型是数学上的复数。我们都知道复数有实部和虚部。所以类complex有两个数据成员re, im。复数有加，减，乘，除，取反，求共轭等操作，类complex也有相对应的成员函数来实现这些操作。下面是类complex的定义和测试代码，已在vs测试过。 类complex的定义 //complex.h #ifndef _MYCOMP...
C++ 面向对象程序设计
2201_75772333的博客
05-03 3759
在面向对象的思想中，我们把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。当然，一个应用程序会包含多个对象，通过多个对象的相互配合即可实现应用程序所需的功能，这样当应用程序功能发生变动时，只需要修改个别对象就可以了，使代码更容易维护。面向对象的程序设计思想可以帮助我们创建结构良好的，可复用的代码，更好地描述和理解真实世界的问题。封装可以隐藏对象的内部表示，只通过对象的方法暴露必要的操作和功能。这使得新类可以复用和扩展已存在的类的代码，提高了代码的复用性，并能够表达类之间的"is-a"关系。
C++面向对象
qq_41721746的博客
08-04 6780
一、引入 实现程序的目的------模拟现实 C语言：struct只有属性没有行为 struct Person { const char* _name; int _sex; int _age; void (*eat)(struct Person* per); void (*run)(struct Person* per); void (*sleep)(struct Person* per); void (*show)(struct Person*
C++ ——面向对象程序设计
prtinf48_9的博客
08-29 6615
是指包含后面所跟的内容，是input output stream的缩写，意思是输入输出流。所以#include定义的就是你要输入和输出的内容。
C++入门——面向对象
beilizhang的博客
07-18 2300
面向对象 面向对象与面向过程，即对象 面向对象把数据即对数据的操作方法放在一起，作为一个相互依存的整体，即对象。对同类对象抽象出其共性，即类，类中的大多数数据都只能被本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。抽象流程由用户在使用中决定 面向过程是一个以事件为中心的开发方法，就是自顶向下顺序执行，逐步求精，其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构，各模块之间的关系也比较简单，在功能上相互独立，每一模块内部都是由顺序、选择和循环三
C++之面向对象（一）
weixin_60535956的博客
05-26 2322
面向对象编程，即面对客观世界存在的对象进行编程，是一种必备的理解思路。
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是学习C++面向对象编程的实战案例，通过设计和实现通讯录管理系统，学生可以深入理解面向对象编程的概念和技巧，并提升解决问题的能力。同时，项目的完整流程，包括需求分析、设计、编码、测试，也能帮助学生...
c++面向对象程序设计语言重点难点复习题及答案.doc
06-27
首先，我们来看看一些关于C++面向对象的重点和难点： 1. 数据共享与保护： - **静态成员**：类的静态数据成员属于类本身，而不是类的实例。这意味着所有类对象共享同一份静态数据成员的拷贝，它们是类的属性，而...
c++面向对象程序设计第三版谭浩强教学大纲.pdf
12-04
本资源摘要信息涵盖了C++面向对象程序设计的基本概念、数据存储、程序设计初步、函数、数组、指针、用户自定义数据类型、类和对象的程序设计等方面的知识点。 第一章 C++初步知识 * C++语言的历史背景和特点 * C++...
《C++面向对象程序设计》第2版编程题答案
02-26
《C++面向对象程序设计》是C++编程领域的一本经典教材，由清华大学出版社出版，龚晓庆、付丽娜等多位专家共同编著。这本书深入浅出地讲解了C++语言的核心概念，特别是面向对象编程（OOP）的思想和技术。第二版在第一...
C++面向对象篇.pdf
12-15
C++面向对象的程序设计，主要总结C++的类和对象，还有C++继承，重载，多态，还有就是数据抽象，数据封装，还讲述了C++接口，（抽象类）
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 926
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 155
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
C++：图的最短路径问题
han2205277149的博客
10-04 1056
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 926
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C++面向对象编程：类与对象基础讲解
本讲义主要涵盖了C++面向对象编程的基础概念，包括类（Class）和对象（Object）的声明和定义，成员函数，对象成员的引用，封装性和信息隐蔽，以及类和对象的简单应用。 首先，面向对象程序设计方法是从现实世界的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值