C++基础学习笔记（四）——核心编程PART2

最新推荐文章于 2024-05-23 20:19:57 发布
最新推荐文章于 2024-05-23 20:19:57 发布
阅读量1k 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 学习 开发语言 类和对象 核心提高
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45719141/article/details/129521562
版权

参考链接：https://www.bilibili.com/video/BV1et411b73Z?p=99&vd_source=b4d9cee68649c8adcb1e266f7147cd5c

一、类与对象

C++面向对象的三大特性为：封装、继承、多态

1.1 封装

1.1.1 封装的意义

封装的意义：
将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制

封装意义一：
在设计类的时候，属性和行为写在一起，表现事物
语法： class 类名{ 访问权限： 属性 / 行为 };

demo1:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;

//圆周率
const double PI = 3.14;

class Circle {
	//访问权限：公共权限
public:
	//属性
	int m_r; //半径
	//行为（函数）
	//获取圆的周长
	double calculateZC()
	{
		return 2 * PI * m_r;
	}

};

int main()
{
	//通过圆类，创建具体的圆（对象)
	//实例化
	Circle c1;
	//给圆对象的属性赋值
	c1.m_r = 10;

	cout<<"圆的周长为：" <<c1.calculateZC()<< endl;

	return 0;
}

圆的周长为：62.8

demo2:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;

//圆周率
const double PI = 3.14;

class Student {
	//访问权限：公共权限
public:
	
	//类中的属性和行为我们统一称为成员
	//属性 成员属性 成员变量
	//行为 成员函数 成员方法

	string Name; //姓名
	int Id; // 学号

	//行为（函数）
	//设置姓名
	void setName(string name)
	{
		Name = name;
	}
	//设置学号
	void setId(int id)
	{
		Id = id;
	}
	//显示
	void show()
	{
		cout<<"学生姓名："<<Name<<endl;
		cout << "学生学号：" << Id << endl;
	}

};

int main()
{

	//实例化
	Student s1;
	//给对象的属性赋值
	s1.Name = "张三";
	s1.Id = 123456;

	s1.show();

	//通过行为给属性赋值
	s1.setName("李四");
	s1.setId(654321);
	s1.show();

	return 0;
}


学生姓名：张三
学生学号：123456
学生姓名：李四
学生学号：654321

封装意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

  1. public 公共权限
  2. protected 保护权限
  3. private 私有权限

保护权限类外不可访问

在这里插入图片描述
私有权限类外不可访问
在这里插入图片描述
demo3:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


class Person {
	

	//访问权限//三种
	//公共权限public 成员类内可以访问类外可以访问
	//保护权限protected 成员类内可以访问类外不可以访问 儿子可以访问父亲中的保护内容
	//私有枚限private 成员类内可以访问类外不可以访问 儿子不可以访问父亲的私有内容

public:
	//公共权限
	string m_Name;  // 姓名
protected:
	//保护权限
	string m_Car;  // 汽车
private:
	//私有权限
	int m_Password;  //银行卡密码
	
public:
	
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;

	}


};

int main()
{
	//实例化具体对象
	Person p1;
	p1.m_Name = "李四";
	//p1.m_Car = "奔驰";  //保护权限内容，在类外访问不到
	//p1.m_Password = 123; //私有权限内容，在类外访问不到

	return 0;
}

1.1.2 struct和class区别

在C++中 struct和class唯一的区别就在于 默认的访问权限不同

区别：
struct 默认权限为公共
class 默认权限为私有

demo4:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


class C1 {
	
	int m_A; // 默认权限：私有

};

struct C2 {

	int m_A; //默认权限：公共
};

int main()
{

	C1 c1;
	//c1.m_A = 100; 类外不可访问

	C2 c2;
	c2.m_A = 100;

	return 0;
}

1.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性

demo5:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


// 设计人类
class Person {

public:
	//设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//获取姓名
	string getName()
	{
		return m_Name;
	}
	//获取年龄 只读
	int getAge()
	{
		m_Age = 0; //初始化为0岁
		return m_Age; 
	}
	// 设置情人  只写
	void setLover(string lover)
	{
		m_Lover = lover;
	}


private:
	string m_Name;  //姓名  可读可写
	int m_Age; // 年龄  只读
	string m_Lover; //情人  只写
};

struct C2 {

	int m_A; //默认权限：公共
};

int main()
{

	Person p;
	p.setName("张三");
	cout << "姓名为: " << p.getName() << endl;
	cout << "年龄为: " << p.getAge() << endl;

	// 设置情人为新垣结衣
	p.setLover("新垣结衣");

	return 0;
}

demo6:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


// 设计人类
class Person {

public:
	//设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//获取姓名
	string getName()
	{
		return m_Name;
	}
	//获取年龄 可读可写，如果想修改，范围必须在0~150之间
	int getAge()
	{
		//m_Age = 0; //初始化为0岁
		return m_Age; 
	}

	void setAge(int age)
	{
		if (age < 0 || age>150)
		{
			m_Age = 0;
			cout << "你这个老妖精！" << endl;
			return;
		}
		m_Age = age;
	}

	// 设置情人  只写
	void setLover(string lover)
	{
		m_Lover = lover;
	}


private:
	string m_Name;  //姓名  可读可写
	int m_Age; // 年龄  只读
	string m_Lover; //情人  只写
};

struct C2 {

	int m_A; //默认权限：公共
};

int main()
{

	Person p;


	p.setName("张三");
	cout << "姓名为: " << p.getName() << endl;
	p.setAge(1000);
	cout << "年龄为: " << p.getAge() << endl;

	// 设置情人为新垣结衣
	p.setLover("新垣结衣");

	return 0;
}

姓名为: 张三
你这个老妖精！
年龄为: 0

练习案例1：设计立方体类

设计立方体类(Cube)
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等。

在这里插入图片描述
demo7:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;

class Cube {

public:


	//行为
	// 设置长
	void setL(double l)
	{
		m_L = l;
	}
	// 获取长
	double getL()
	{
		return m_L;
	}
	// 设置宽
	void setW(double w)
	{
		m_W = w;
	}
	// 获取宽
	double getW()
	{
		return m_W;
	}
	// 设置高
	void setH(double h)
	{
		m_H = h;
	}
	// 获取高
	double getH()
	{
		return m_H;
	}

	//计算面积
	double CalSquare()
	{
		double S;
		S = 2 * m_L * m_W + 2 * m_L * m_H + 2 * m_H * m_W;
		return S;
	}
	//计算体积
	double CalVolume()
	{
		double V;
		V = m_L * m_W * m_H;
		return V;
	}
	//利用成员函数判断两个立方体是否相等
	bool isSameByClass(Cube& c)
	{
		if (m_L == c.getL() && m_W == c.getW() && m_H == c.getH())
		{
			return true;
		}
		return false;
	}
	
private:  
	//属性 属性都尽量设置为私有
	double m_L; //长
	double m_W; //宽
	double m_H; //高
};

//全局函数判断两个立方体是否相等
bool isSame(Cube &C1, Cube &C2)
{
	if (C1.getL() == C2.getL() && C1.getW() == C2.getW() && C1.getH() == C2.getH())
	{
		return true;
	}
	return false;
}

int main()
{
	Cube C1;
	C1.setL(10);
	C1.setW(10);
	C1.setH(10);

	cout << "第一个立方体面积为：" << C1.CalSquare() << "  体积为：" << C1.CalVolume() << endl;

	Cube C2;
	C2.setL(10);
	C2.setW(5);
	C2.setH(2);

	cout << "第二个立方体面积为：" << C2.CalSquare() << "  体积为：" << C2.CalVolume() << endl;

	//利用全局函数判断
	bool ret = isSame(C1, C2);
	if (ret)
	{
		cout << "利用全局函数判断：C1和C2两个立方体相等" << endl;
	}
	cout << "利用全局函数判断：C1和C2两个立方体不相等" << endl;

	//利用成员函数判断
	ret = C1.isSameByClass(C2);
	if (ret)
	{
		cout << "利用成员函数判断：C1和C2两个立方体相等" << endl;
	}
	cout << "利用成员函数判断：C1和C2两个立方体不相等" << endl;

	return 0;
}


第一个立方体面积为：600  体积为：1000
第二个立方体面积为：160  体积为：100
利用全局函数判断：C1和C2两个立方体不相等
利用成员函数判断：C1和C2两个立方体不相等

练习案例2：点和圆的关系

设计一个圆形类（Circle），和一个点类（Point），计算点和圆的关系。

在这里插入图片描述
自己先动手实现一次:

demo8:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;

// 圆类
class Circle {

public:

	//行为
    // 获取圆心的X坐标
	double getCenterX()
	{
		return m_CenterX;
	}
	// 设置圆心的X坐标
	void setCenterX(double center_x)
	{
		m_CenterX = center_x;
	}
	// 获取圆心的Y坐标
	double getCenterY()
	{
		return m_CenterY;
	}
	// 设置圆心的Y坐标
	void setCenterY(double center_y)
	{
		m_CenterY = center_y;
	}
	// 获取圆的半径
	double getR()
	{
		return m_R;
	}
	// 设置圆的半径
	void setR(double r)
	{
		m_R = r;
	}
	
private:  
	//属性 属性都尽量设置为私有
	double m_CenterX;  // 圆心的X坐标
	double m_CenterY;  // 圆心的Y坐标
	double m_R; //圆的半径
};

// 点类
class Point {

public:

	//行为
	// 获取点的X坐标
	double getX()
	{
		return m_X;
	}
	// 设置点的X坐标
	void setX(double x)
	{
		m_X = x;
	}
	// 获取点的Y坐标
	double getY()
	{
		return m_Y;
	}
	// 设置点的Y坐标
	void setY(double y)
	{
		m_Y = y;
	}

private:
	//属性 属性都尽量设置为私有
	double m_X;  // 点的X坐标
	double m_Y;  // 点的Y坐标
};

//计算点到圆心之间的距离
double CalDistance(Circle& c1, Point& p1)
{
	double d;
	d = sqrt(pow((c1.getCenterX() - p1.getX()), 2) + pow((c1.getCenterY() - p1.getY()), 2));

	return d;
}

int main()
{
	Circle c1;
	c1.setCenterX(0);
	c1.setCenterY(0);
	c1.setR(5);

	Point p1;
	p1.setX(2);
	p1.setY(2);

	double cal_d = CalDistance(c1, p1);
	if (cal_d > c1.getR())
	{
		cout << "点和圆的关系是：点在圆外" << endl;
	}
	else if (cal_d < c1.getR())
	{
		cout << "点和圆的关系是：点在圆内" << endl;
	}
	else
	{
		cout << "点和圆的关系是：点在圆上" << endl;
	}
	return 0;
}

点和圆的关系是：点在圆内

教程写的：

demo9：

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;

// 点类
class Point {

public:

	//行为
	// 获取点的X坐标
	double getX()
	{
		return m_X;
	}
	// 设置点的X坐标
	void setX(double x)
	{
		m_X = x;
	}
	// 获取点的Y坐标
	double getY()
	{
		return m_Y;
	}
	// 设置点的Y坐标
	void setY(double y)
	{
		m_Y = y;
	}

private:
	//属性 属性都尽量设置为私有
	double m_X;  // 点的X坐标
	double m_Y;  // 点的Y坐标
};



// 圆类
class Circle {

public:

	//行为
	//获取圆的半径
	double getR()
	{
		return m_R;
	}
	// 设置圆的半径
	void setR(double r)
	{
		m_R = r;
	}
	// 获取圆心
	Point getCenter()
	{
		return m_Center;
	}
	// 设置圆心
	void setCenter(Point center)
	{
		m_Center = center;
	}
	
private:  
	//属性 属性都尽量设置为私有
	double m_R; //圆的半径
	//在类中可以让另一个类，作为本类中的成员
	Point m_Center;  //圆心点
};





//判断点和圆的关系
void isInCircle(Circle& c, Point& p)
{
	//计算两点之间的距离 平方
	double distance;
	distance = pow(c.getCenter().getX() - p.getX(), 2) + pow(c.getCenter().getY() - p.getY(), 2);
	//半径 平方
	double rDistance;
	rDistance = pow(c.getR(), 2);
	//判断关系
	if (distance == rDistance)
	{
		cout << "点和圆的关系是：点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
		cout << "点和圆的关系是：点在圆外" << endl;
	}
	else
	{
		cout << "点和圆的关系是：点在圆内" << endl;
	}

}


int main()
{
	// 创建圆
	Circle c;
	c.setR(10);
	Point center; //利用点类创建圆心
	center.setX(10);
	center.setY(0);
	c.setCenter(center);


	//创建点
	Point p;
	p.setX(10);
	p.setY(10);

	//判断关系
	isInCircle(c, p);

	return 0;
}

点和圆的关系是：点在圆上

把类写在另一个文件中——头文件申明，源文件实现

step1：复制有关类的代码段，并注释掉原来的

在这里插入图片描述

step2：在头文件中，创建出一个名为point.h的头文件（.h)
在这里插入图片描述

step3：在源文件中，创建出一个名为point.cpp的源文件(.cpp)
在这里插入图片描述
step4：在头文件中，先写上一句 #pragma once，防止头文件重复包含

在这里插入图片描述
step5：加上#include<iostream> using namespace std; 这里只需要成员函数的声明；即删去实现，加一个分号补全。但同时，变量的声明肯定也是要留住的。

在这里插入图片描述
step6：在cpp文件中，先包括一下刚刚的头文件，#include "point.h", 然后把代码粘贴过来；

在这里插入图片描述
step7：删掉关于class,pubilic等语句，仅保留函数的声明与实现；并且给函数名加上作用域，告诉是在Point作用域下的成员函数

在这里插入图片描述
step8: Circle类也按这样操作，但发现Point处报错。

在这里插入图片描述

解决办法：在代码前面把它的头文件添加进来。
在这里插入图片描述
step9: 在其他的文件中使用，只需要包含这两个头文件即可。
在这里插入图片描述
上述代码修改为：

demo10：

在这里插入图片描述

point.h

#pragma once
#include<iostream>
using namespace std;

// 点类
class Point {

public:

	//行为
	// 获取点的X坐标
	double getX();

	// 设置点的X坐标
	void setX(double x);

	// 获取点的Y坐标
	double getY();

	// 设置点的Y坐标
	void setY(double y);

private:
	//属性 属性都尽量设置为私有
	double m_X;  // 点的X坐标
	double m_Y;  // 点的Y坐标
};

point.cpp

#include "point.h"



//行为
// 获取点的X坐标
double Point::getX()
{
	return m_X;
}
// 设置点的X坐标
void Point::setX(double x)
{
	m_X = x;
}
// 获取点的Y坐标
double Point::getY()
{
	return m_Y;
}
// 设置点的Y坐标
void Point::setY(double y)
{
	m_Y = y;
}

circle.h

#pragma once
#include<iostream>
using namespace std;
#include "point.h"


// 圆类
class Circle {

public:

	//行为
	//获取圆的半径
	double getR();

	// 设置圆的半径
	void setR(double r);

	// 获取圆心
	Point getCenter();

	// 设置圆心
	void setCenter(Point center);

private:
	//属性 属性都尽量设置为私有
	double m_R; //圆的半径
	//在类中可以让另一个类，作为本类中的成员
	Point m_Center;  //圆心点
};

circle.cpp

#include "circle.h"




//行为
//获取圆的半径
double Circle::getR()
{
	return m_R;
}
// 设置圆的半径
void Circle::setR(double r)
{
	m_R = r;
}
// 获取圆心
Point Circle::getCenter()
{
	return m_Center;
}
// 设置圆心
void Circle::setCenter(Point center)
{
	m_Center = center;
}

点圆关系.cpp （主代码）

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;
#include "point.h"
#include "circle.h"


//判断点和圆的关系
void isInCircle(Circle& c, Point& p)
{
	//计算两点之间的距离 平方
	double distance;
	distance = pow(c.getCenter().getX() - p.getX(), 2) + pow(c.getCenter().getY() - p.getY(), 2);
	//半径 平方
	double rDistance;
	rDistance = pow(c.getR(), 2);
	//判断关系
	if (distance == rDistance)
	{
		cout << "点和圆的关系是：点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
		cout << "点和圆的关系是：点在圆外" << endl;
	}
	else
	{
		cout << "点和圆的关系是：点在圆内" << endl;
	}

}


int main()
{
	// 创建圆
	Circle c;
	c.setR(10);
	Point center; //利用点类创建圆心
	center.setX(10);
	center.setY(0);
	c.setCenter(center);


	//创建点
	Point p;
	p.setX(10);
	p.setY(10);

	//判断关系
	isInCircle(c, p);

	return 0;
}

运行结果：

点和圆的关系是：点在圆上

1.2 对象的初始化和清理

生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据
保证安全
C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。

1.2.1 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题
一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和
清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提
供
编译器提供的构造函数和析构函数是空实现。

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手
动调用。
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法： 类名(){}

  1. 构造函数，没有返回值也不写void
  2. 函数名称与类名相同
  3. 构造函数可以有参数，因此可以发生重载
  4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法： ~类名(){}

  1. 析构函数，没有返回值也不写void
  2. 函数名称与类名相同,在名称前加上符号 ~
  3. 析构函数不可以有参数，因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

创建在栈区的对象：

demo11:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;

//对象的初始化和清理

//构造函数 进行初始化操作
//自动调用
class Person
{
public:
	Person()
	{
		cout << "Person 构造函数的调用" << endl;
	}

	//析构函数 进行清理的工作
	//不可以有参数
	~Person()
	{
		cout<< "Person 析构函数的调用" << endl;
	}

};



void test01()
{
	Person p; //在栈上的数据，test01执行完毕后，释放这个对象；所以会调用析构函数
}

int main()
{

	test01();
	return 0;
}

Person 构造函数的调用
Person 析构函数的调用

创建在main函数的对象：

demo12:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;

//对象的初始化和清理

//构造函数 进行初始化操作
//自动调用
class Person
{
public:
	Person()
	{
		cout << "Person 构造函数的调用" << endl;
	}

	//析构函数 进行清理的工作
	//不可以有参数
	~Person()
	{
		cout<< "Person 析构函数的调用" << endl;
	}

};



void test01()
{
	Person p; //在栈上的数据，test01执行完毕后，释放这个对象；所以会调用析构函数
}

int main()
{

	//test01();

	Person p;

	return 0;
}

在这里插入图片描述

发现还是调用了析构函数，这是因为没有写system("pause")语句，程序执行完毕销毁调用了析构函数。
执行到system("pause")语句，程序就中断了。不会再往下执行。等把整个main函数都执行完了，才会执行释放的操作。

加了这一句后：

在这里插入图片描述
1.2.2 构造函数的分类及调用

两种分类方式：
按参数分为： 有参构造和无参构造
按类型分为： 普通构造和拷贝构造

三种调用方式：
括号法
显示法
隐式转换法

括号法：

demo13:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;



class Person
{
public:

	//构造函数
	//参数分类：无参构造（默认构造）和有参构造
	//类型分类： 普通构造 拷贝构造
	Person()
	{
		cout << "Person 无参构造函数的调用" << endl;
	}

	Person(int a)
	{
		age = a;
		cout << "Person 有参构造函数的调用" << endl;
	}

	//拷贝构造函数
	Person(const Person &p) //加const不修改原来本身；引用传参
	{
		age = p.age;
		cout << "Person 拷贝构造函数的调用" << endl;
	}

	//析构函数 
	~Person()
	{
		cout<< "Person 析构函数的调用" << endl;
	}

	int age;

};


//调用
void test01()
{
	
	//括号法 	
	Person p;  //默认构造函数的调用
	Person p2(10);  //有参构造函数的调用
	Person p3(p2); //拷贝构造函数的调用

	//注意事项
	//调用默认构造函数的时候吗，不要加()
	//因为会被编译器认为是函数声明； Person p1();不会认为在创建对象

	cout << "p2的年龄为：" << p2.age << endl;
	cout << "p3的年龄为：" << p3.age << endl;
	//显示法
	//隐式转换法

}

int main()
{
	test01();

	system("pause");

	return 0;
}

Person 无参构造函数的调用
Person 有参构造函数的调用
Person 拷贝构造函数的调用
p2的年龄为：10
p3的年龄为：10
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用

	//显示法
	Person p1;
	Person p2 = Person(10);  //有参构造  
	Person p3 = Person(p2);  //有参构造

Person 无参构造函数的调用
Person 有参构造函数的调用
Person 拷贝构造函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用

匿名对象的特点：

在这里插入图片描述
显式法：

注意事项：不要利用拷贝构造函数 初始化匿名对象 编译器会认为Person(p3)等价于Person p3;
在这里插入图片描述
隐式法：

在这里插入图片描述
1.2.3 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况
1.使用一个已经创建完毕的对象来初始化一个新对象

在这里插入图片描述
2.值传递的方式给函数参数传值

在这里插入图片描述

3.以值方式返回局部对象

在这里插入图片描述
p1和p不是同一个对象，地址不一样。
在这里插入图片描述

全部代码

demo14:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;



class Person
{
public:

	//构造函数
	//参数分类：无参构造（默认构造）和有参构造
	//类型分类： 普通构造 拷贝构造
	Person()
	{
		cout << "Person 默认构造函数的调用" << endl;
	}

	Person(int age)
	{
		m_Age = age;
		cout << "Person 有参构造函数的调用" << endl;
	}

	//拷贝构造函数
	Person(const Person &p) //加const不修改原来本身；引用传参
	{
		m_Age = p.m_Age;
		cout << "Person 拷贝构造函数的调用" << endl;
	}



	//析构函数 
	~Person()
	{
		cout<< "Person 析构函数的调用" << endl;
	}

	int m_Age;

};


//调用
//使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);
	Person p2(p1);
	
	cout << "p2的年龄为：" << p2.m_Age << endl;

}

//值传递的方式给函数参数传值;值传递的本质：拷贝临时的副本
void doWork(Person p)
{
	
}
void test02()
{
	Person p;
	doWork(p);
}

//以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int*)&p1 << endl; //int*输出十六进制结果，不加输出十进制
	return p1;  //局部对象的特点：函数执行完毕后，就会被释放掉
}

void test03()
{
	Person p = doWork2();
	cout << (int*)&p << endl;

}

int main()
{
	//test01();
	//test02();
	test03();

	system("pause");

	return 0;
}

1.2.4 构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：
1.如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
2.如果用户定义拷贝构造函数，c++不会再提供其他构造函数

自己写的拷贝函数：
在这里插入图片描述

注释掉自己写的拷贝构造函数

发现少了一句打印的，是因为自己写的都被注释掉了。实际编译器会执行一条像第27行那样的代码，进行拷贝。
在这里插入图片描述

如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造：

注释掉自己写的默认无参构造函数，并进行无参构造调用。

发现报错：提示没有合适的默认构造函数可用。

在这里插入图片描述
进行有参构造函数调用：

能成功运行。
在这里插入图片描述
如果用户定义拷贝构造函数，c++不会再提供其他构造函数：

注释掉除了拷贝构造函数之外的其他写的函数，发现在进行有参和无参构造函数调用的时候就会报错
在这里插入图片描述
1.2.5 深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

析构函数，将堆区开辟数据做释放操作、

栈区：先进后出

浅拷贝：堆区内存的重复释放。p2先释放，然后p1释放。

在这里插入图片描述
在这里插入图片描述

demo15:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
#include <math.h>
using namespace std;



class Person
{
public:

	//构造函数
	Person()
	{
		cout << "Person 默认构造函数的调用" << endl;
	}

	Person(int age, int height)
	{
		m_Age = age;
		m_Height = new int(height); //new创建的数据返回对应的指针；堆区的数据
		cout << "Person 有参构造函数的调用" << endl;
	}


	//自己实现拷贝构造函数 解决浅拷贝带来的问题
	Person(const Person& p)
	{
		cout << "Person 拷贝构造函数的调用" << endl;
		m_Age = p.m_Age;
		//m_Height = p.m_Height;  编译器默认实现就是这行代码
		// 
		//深拷贝操作
		m_Height = new int(*p.m_Height);
	}
	//析构函数 
	~Person()
	{
		//析构函数，将堆区开辟数据做释放操作
		if (m_Height != NULL)
		{
			delete m_Height;  //释放
			m_Height = NULL;
		}
		cout<< "Person 析构函数的调用" << endl;
	}

	int m_Age;  //年龄
	int* m_Height;  //身高

};


void test01()
{
	Person p1(18,160);

	cout << "p1的年龄为：" << p1.m_Age <<" 身高为：" <<*p1.m_Height<< endl;  //*解引用

	Person p2(p1);

	cout << "p2的年龄为：" << p2.m_Age << " 身高为：" << *p2.m_Height << endl;


}



int main()
{
	test01();


	system("pause");

	return 0;
}

Person 有参构造函数的调用
p1的年龄为：18 身高为：160
Person 拷贝构造函数的调用
p2的年龄为：18 身高为：160
Person 析构函数的调用
Person 析构函数的调用

1.2.6 初始化列表

作用：
C++提供了初始化列表语法，用来初始化属性

语法： 构造函数()：属性1(值1),属性2（值2）... {}

demo16:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


class Person
{
public:

	传统初始化操作
	//Person(int a, int b, int c)
	//{
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表初始化属性
	Person(int a, int b,int c) :m_A(a), m_B(b), m_C(c)
	{

	}

	int m_A;
	int m_B;
	int m_C;

};

void test01()
{
	//Person p(10, 20, 30);
	Person p(30, 20, 10);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;

}



int main()
{
	test01();

	system("pause");

	return 0;
}

m_A = 30
m_B = 20
m_C = 10

1.2.7 类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员

例如：

class A {}
class B
{
A a；
}

B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

当其他类对象作为本类成员，构造时候先构造类对象，再构造自身。析构的顺序与构造相反。

demo17:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;


class Phone {
public:

	Phone(string pName)
	{
		cout << "Phone的构造函数调用" << endl;
		m_PName = pName;
	}
	~Phone()
	{
		cout << "Phone的析构函数调用" << endl;
	}
	//手机品牌名称
	string m_PName;
};

class Person
{
public:
	//Phone m_Phone = pName; 隐式转换法
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person的构造函数调用" << endl;
	}

	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

	//姓名
	string m_Name;
	//手机
	Phone m_Phone;


};

void test01()
{
	Person p("吴京", "iphone 13 pro max 冷锋蓝");
	cout << p.m_Name << "拿着："<<p.m_Phone.m_PName << endl;

}



int main()
{
	test01();

	system("pause");
	return 0;
}


Phone的构造函数调用
Person的构造函数调用
吴京拿着：iphone 13 pro max 冷锋蓝
Person的析构函数调用
Phone的析构函数调用

1.2.8 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化

静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量

经过p2的修改，数据也变了，说明是所有对象共享同一份数据。
在这里插入图片描述
静态成员变量，不属于某个对象上，所有对象都共享同一份数据。
因此，静态成员变量有两种访问方式：
1.通过对象进行访问
2.通过类名进行访问

在这里插入图片描述
在这里插入图片描述
静态成员变量也是有访问权限的
在这里插入图片描述

demo18:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;



class Person
{
public:
	
	//所有对象都共享同一份数据
	//编译阶段就分配内存
	//类内声明，类外初始化操作
	static int m_A;

	//静态成员变量也是有访问权限的
private:
	static int m_B;


};

int Person::m_A = 100; //加Person::与全局变量相区分
int Person::m_B = 200;

void test01()
{
	Person p;
	cout << p.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << p.m_A << endl;

}

void test02()
{
	//通过对象进行访问
	//Person p;
	//cout << p.m_A << endl;
	//通过类名进行访问
	cout << Person::m_A << endl;
	//cout << Person::m_B << endl;  类外访问不到私有静态成员变量
}


int main()
{
	//test01();
	test02();

	system("pause");
	return 0;
}

静态成员函数

通过对象访问
在这里插入图片描述
通过类名访问
在这里插入图片描述
静态成员函数不可以访问非静态成员变量：因为无法区分到底是哪个对象的m_B属性
在这里插入图片描述
静态成员函数也是有访问权限的

在这里插入图片描述

demo19:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;



class Person
{
public:
	
	//所有对象都共享同一个函数
	//静态成员函数只能访问静态成员变量

	//静态成员函数
	static void func()
	{
		m_A = 100; //静态成员函数可以访问 静态成员变量
		//m_B = 200;  //静态成员函数不可以访问非静态成员变量：因为无法区分到底是哪个对象的m_B属性
		cout << "static void func调用" << endl;
	}

	static int m_A; //静态成员变量
	int m_B;

	//静态成员函数也是有访问权限的
private:
	static void func2()
	{
		cout << "static void func2调用" << endl;
	}


};

int Person::m_A = 0;

void test01()
{
	//通过对象来访问
	//Person p;
	//p.func();

	//通过类名访问
	Person::func();
	//Person::func2();  类外访问不到私有静态成员函数
}




int main()
{
	test01();

	system("pause");
	return 0;
}


static void func调用

1.3 C++对象模型和this指针

1.3.1 成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上

//空对象占用内存空间为：1
//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
//每个空对象也应该有个独一无二的内存地址

非静态成员变量 属于类的对象上的

一旦有了成员变量，就不是空对象，所以字节空间看成员变量。
在这里插入图片描述

静态成员变量 不属于类的对象上

在这里插入图片描述
非静态成员函数 不属于类的对象上

在这里插入图片描述
静态成员函数 不属于类的对象上
在这里插入图片描述

demo20:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;



class Person
{
	
	int m_A; //非静态成员变量  属于类的对象上的

	static int m_B; // 静态成员变量  不属于类的对象上

	void func() //非静态成员函数  不属于类的对象上
	{
	}

	static void func2() //静态成员函数  不属于类的对象上
	{
	}
};

int Person::m_B = 0;

void test01()
{
	Person p;
	//空对象占用内存空间为：1
	//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	//每个空对象也应该有个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}

void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}



int main()
{
	//test01();
	test02();

	system("pause");
	return 0;
}

1.3.2 this指针概念

通过1.3.1我们知道在C++中成员变量和成员函数是分开存储的
每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
那么问题是：这一块代码是如何区分那个对象调用自己的呢？

c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可

this指针的用途：
当形参和成员变量同名时，可用this指针来区分
在类的非静态成员函数中返回对象本身，可使用return *this

编译器认为这三个age是一样的，属性age并没有被赋值。
在这里插入图片描述
可以写成下面这样，以作区分

在这里插入图片描述
或者用this指针（this指针指向被调用的成员函数所属的对象）

在这里插入图片描述
下面代码可以运行
在这里插入图片描述
修改为：返回对象本身

在这里插入图片描述
删除了引用符号，发现只返回20。
在这里插入图片描述

以值返回局部对象会调用拷贝构造函数，对p2进行一次PersonAddAge操作后，将p2的结果拷贝为p2’,所以p2还是经过了一次加年龄的操作。但后面的PersonAddAge操作都是对p2’,p2"了，所以p2.age不会一直增加

demo21:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;



class Person
{
public:
	Person(int age)
	{
		//this指针指向被调用的成员函数所属的对象,即p1
		this->age = age;
	}

	Person PersonAddAge(Person& p)
	{
		this->age += p.age;
		//this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}

	int age;
};

//解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}

//返回对象本身用*this
void test02()
{
	Person p1(10);

	Person p2(10);

	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);

	cout << "p2的年龄为：" << p2.age<<endl;
}



int main()
{
	//test01();
	test02();

	system("pause");
	return 0;
}

1.3.3 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

在这里插入图片描述
单独运行下面那个函数调用，报错。
在这里插入图片描述
这是因为第二个函数用到了属性，默认有个this->m_Age，表示这是当前对象的属性。

而因为没有对象，只是一个空指针，无法访问里面的属性。

在这里插入图片描述
加一行判断，提升代码健壮性，不会报错。

在这里插入图片描述
demo22:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;

class Person
{
public:
	void showClassName()
	{
		cout << "This is Person class" << endl;
	}

	void showPersonAge()
	{
		if (this == NULL)
		{
			return;  //确保不会走到下一行
		}
		cout << "age= " << this->m_Age << endl;
	}
	int m_Age;
};

//解决名称冲突
void test01()
{
	Person * p = NULL;
	//p->showClassName(); //空指针，可以调用成员函数
	//报错原因是因为传入的指针为NULL
	p->showPersonAge(); //但是如果成员函数中用到了this指针，就不可以了
}


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

1.3.4 const修饰成员函数

常函数：
成员函数后加const后我们称为这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：
声明对象前加const称该对象为常对象
常对象只能调用常函数

可以修改成员属性：
在这里插入图片描述

加了const，变成常函数后，不能修改成员属性。

在这里插入图片描述
关于this指针
在这里插入图片描述
这里的this相当于Person *const this，不可以修改指向；

const Person *const this，在前面再加一个const，使得指针指向的值也不可以更改。

所以对于常函数，把const加在最后，相当于让其值也不可以更改。

在这里插入图片描述
在成员函数前加const,修饰的是this指向，让指针指向的值也不可以更改

常对象

也不可以修改气属性，但如果是p.m_B = 100; 就不会报错
在这里插入图片描述
常对象只能调用常函数

常对象不可以调用普通成员函数，因为普通成员函数可以修改属性
在这里插入图片描述
demo23:

#include<iostream>
//#include<string> //用C++风格字符串，要包含这个头文件,但VS2019其实也可以不用加
using namespace std;

class Person
{
public:
	//常函数
	//this指针的本质是 指针常量 指针的指向是不可以修改的
	// const Person *const this;
	// 在成员函数前加const,修饰的是this指向，让指针指向的值也不可以更改
	void showPerson() const
	{
		this->m_B = 100;
		//this->m_A = 100;  //但指针指向的值可以修改
		//this = NULL;  //this指针是不可以修改指针的指向的
	}

	//普通函数
	void func()
	{

	}

	int m_A;
	int mutable m_B; //特殊变量，即使在常函数中，也可以修改这个值；加上关键字mutable
};

void test01()
{
	Person p;
	p.showPerson();
}

//常对象
void test02()
{

	const Person p;//在对象前加const，变为常对象
	//p.m_A = 100;
	p.m_B = 100; //特殊值，在常对象下，也可以修改

	//常对象只能调用常函数
	p.showPerson();
	//p.func();  常对象不可以调用普通成员函数，因为普通成员函数可以修改属性
}


int main()
{
	test01();
	system("pause");
	return 0;
}
子非鱼icon
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++基础学习笔记————网课
08-18
个人网课学习笔记
圆类（C++)
m0_73509997的博客
04-04 376
圆的面积为：1661.06。圆的周长为：144.44。请输入圆的半径：23。
C++编写一个关于圆形的程序,要求定义一个圆形类Circle
热门推荐
qq_58619891的博客
10-04 1万+
1、编写一个关于圆形的C++程序。要求定义一个圆形类Circle，其中包含如下成员： 1）1个私有数据成员（半径）。 2）3个公有函数成员（设置半径、计算面积、计算周长）。 3）3个构造函数（不带参数的构造函数，带参数的构造函数和拷贝构造函数）。 //函数main使用圆形类Circle创建圆形对象，要求 1）定义一个圆对象c1，从键盘输入一个值x，并将其设定为c1的半径，计算并显示c1的面积和周长 2）再定义一个圆对象c2，并将半径初始化为2x，计算并显示c2的面积和周长 3）再定义一个圆对象c3，并用c1
C++基础实例-类(7)
Swxctx
05-05 581
enum与class **在C++中，虚函数可称其为他的灵魂，其中加入指针，才会真正体现他的美妙。 #if 0 /*enum与class*/ #include using namespace std; enum Color {Red,Yellow,Green,White}; //圆类Circle的定义 class Circle { float radius; public:
使用C++编写的简单示例，实现计算圆的面积功能
m0_74288622的博客
05-02 1890
在Circle类的构造函数中，我们可以选择使用默认半径为0，也可以使用传入的参数进行初始化。在setRadius()函数中，我们修改m_radius的值。在getArea()函数中，我们使用M_PI常量和m_radius计算圆的面积。在Circle类中，我们声明了构造函数、获取半径、设置半径和计算面积的成员函数，其中m_radius是一个私有成员变量，用于存储圆的半径。在main()函数中，我们提示用户输入圆的半径，然后创建一个Circle对象，并调用getArea()函数计算面积并输出。
C++程序设计2018年10月考试设计题代码参考
AnsonNie的博客
10-23 1987
设计一个圆类Circle和一个桌子类Table，类Circle包含私有数据成员半径radius和求圆面积的成员函数getarea()，类Table包含私有数据成员高度height和成员函数getheight()，另设计一个圆桌类Roundtable是类Circle和类Table两个类的派生，私有数据成员color和成员函数getcolor()，要求输出一个圆桌的面积、高度和颜色等数据.   VC...
C++基础学习笔记（五）——核心编程PART3
weixin_45719141的博客
03-30 1073
关于C++核心编程的学习记录笔记
C++整理笔记word版 ——02 C++核心编程
12-06
C++整理笔记word版 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。是01 C++学习笔记的后续补充 内存分区模型 引用 函数提高 类和对象 文件操作
C++整理笔记word版——01 C++学习笔记
12-05
C++基础的学习笔记（其中的代码源件可私信留言） C++中的空头程序 使用C++书写hello world 学习变量 学习常量 标识符命名规则 数据类型 运算符 程序流程结构 数组 函数 指针 结构体
C++提高编程 学习笔记
05-11
C++提高编程 学习笔记
C++创建圆类
m0_66760074的博客
05-07 1167
#include <iostream> using namespace std; class CCircle{ public : void setR(double pr){ cin>>r; }; void getPerimeter(){ double s=0; s=6.28*r; cout<<"the perimeter is "<<s<<endl; .
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 684
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
Python教程：使用Python和PyQt编写进制转换器工具
复现的博客
05-23 258
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
c++ const 的多种用途
05-17 149
常成员函数，不能修改对象的成员变量，也不能调用类中任何非 const 成员函数。该对象为常量对象，其中的任何成员都不能被修改，不能调用其他非const成员函数。const 在 * 左边。指针指向的值不可变，即 *p 不可修改。const 在 * 右边。指针本身不可变，即 p 不可修改。参数在函数内部不可改变。
c语言操作注意事项
dropLin的博客
05-20 182
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
【C++】多态
malloc不出对象的博客
05-23 361
本篇文章讲解的C++中的多态，它是面向对象语言中最重要的特性之一，它能对同一行为表现出不同的形态！！
C++质数的那些事（判断指数、区间筛质数、互质等等）
最新发布
A1063348628的博客
05-23 109
质数的定义：若一个正整数除了1和它自身之外不能被任何自然数整除，则该数称为质数，也叫素数。否则为合数。质数的性质：质数的分布较为稀疏，对于一个足够大的数S，不超过S的质数大约有个，也就是说每InN个数约有一个质数，代码： 二、筛出给定区间的质数 代码（欧拉筛（线性筛））： 三、判断两个整数是否互质 代码： 代码会随个人学习进行持续更新，谢谢您的观看！
零基础c++学习笔记pdf
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和练习。同时，这份学习笔记也包含了C语言的一些高级内容，比如文件操作、指针等，这对于学习者来说非常有用。 学习C语言需要具备一定的数学和逻辑思维能力，但是该pdf对于这些方面也进行了详细的解释，让初学者能够轻松理解。此外，该pdf的讲解非常通俗易懂，对于初学者来说非常友好，学习起来容易上手。如果你想学习C语言，并且没有任何编程经验，那么这份学习笔记非常值得一看。你可以通过学习这份笔记，掌握C语言这门编程语言的基础知识，并且能够基于这门语言进行开发。总的来说，《零基础C语言学习笔记》pdf对于初学者来说是一份非常好的学习资料。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值