【c++】c++基础入门

已于 2022-10-03 16:27:15 修改
阅读量739 收藏 2
点赞数
分类专栏： c++数据结构学习 文章标签： c++ 开发语言
于 2022-09-23 07:38:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64548999/article/details/127003284
版权

目录

C++基础入门

学习视频

注：下文中视频密码：123456

C++初识

第一个程序

头尾部
#include <iostream>
using namespace std;

int main()
{
	system("pause");
	return 0;
}
hello world
#include <iostream>
using namespace std;

int main()
{
	cout << "hello world" << endl;

	system("pause");
	return 0;
}

注释

单行注释
  1. // 描述信息
  • 通常放在一行代码的上方，或者—条语句的末尾，对该行代码说明
多行注释
  1. /* 描述信息 */
  • 通常放在一段代码的上方，对该段代码做整体说明

变量

作用:给一段指定的内存空间起名，方便操作这段

内存语法:数据类型 变量名 = 初始值；

#include <iostream>
using namespace std;

int main()
{
	// 变量的定义
	// 语法：数据类型 变量名 = 初始值

	int a = 10;

	cout << "a = " << a << endl;

	system("pause");
	return 0;
}

常量

作用：用于记录程序中不可更改的数据

  1. #define宏常量：#define 常量名 常量值
  • 通常在文件上方定义，表示—个常量
  1. const修饰的变量 const 数据类型 常量名 = 常量值
  • 通常在变量定义前加关键字const。修饰该变量为常量，不可修改
#include <iostream>
using namespace std;

/*
常量的定义方法
1、#define 宏常量
2、const修饰的变量
*/

//1、#define 宏常量
#define day 7

int main()
{
	//day = 14; //错误，day是常量，一旦修改就会报错
	cout << "一周总共有：" << day << "天" << endl;

	//2、const修饰的变量
	const int month = 12;
	//month = 24; //错误，const修饰的变量也称为常量

	cout << "一年总共有：" << month << "个月份" << endl;

	system("pause");
	return 0;
}

关键字

作用：关键字是C++中预先保留的单词（标识符）

  • 在定义变量或者常量时候，不要用关键字
asmdoifreturntypedef
autodoubleinlineshorttypeid
booldynamic_castintsignedtypename
breakelselongsizeofunion
caseenummutablestaticunsigned
catchexplicitnamespacestatic_castusing
charexportnewstructvirtual
classexternoperatorswitchvoid
constfalseprivatetemplatevolatile
const_castfloatprotectedthiswchar_t
continueforpublicthrowwhile
defaultfriendregistertrue
deletegotoreinterpret_casttry

标识符命名规则

作用：C++规定给标识符(变量、常量)命名时，有一套自己的规则

  • 标识符不能是关键字
  • 标识符只能由字母、数字、下划线组成
  • 第一个字符必须为字母或下划线
  • 标识符中字母区分大小写

数据类型

C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存

整型

作用：整型变量表示整数类型的数据。

数据类型占用空间取值范围
short(短整型)2字节(-2^15 ~ 2^15-1)
int(整型)4字节(-2^31 ~ 2^31-1)
long(长整形)Windows为4字节，Linux为4字节(32位)，8字节(64位)(-2^31 ~ 2^31-1)
long long(长长整形)8字节(-2^63 ~ 2^63-1)

sizeof关键词

作用：利用sizeof关键字可以统计数据类型所占内存大小

语法：sizeof(数据类型 / 变量)

整型结论：short < int <= long <=long long

实型(浮点型)

作用：浮点型变量表示小数类型的数据。

  1. 单精度float

  2. 双精度double

两者区别在于表示的有效数字范围不同。

数据类型占用空间有效数字范围
float4字节7位有效数字
double8字节15～16位有效数字

注1：有效数字包括整数部分和小数部分。
注2：C++输出多位小数时默认会显示6位有效数字，需进行额外配置以完整显示全部有效数字。
注3：float类型表示小数时，在数字末尾显式地使用字母f表示单精度，否则编译器会默认将小数视为双精度浮点型（double），再进行类型转换（由double型转换为float型）。

int main()
{
	float f1 = 3.1415926535f;
	cout << "float 类型占用的内存大小：" << sizeof(float) << endl;
	cout << "float 类型占用的内存大小：" << sizeof(f1) << endl;

	double d1 = 3.1415926535;
	cout << "double 类型占用的内存大小：" << sizeof(double) << endl;
	cout << "double 类型占用的内存大小：" << sizeof(d1) << endl;

	//科学计数法表示整数
	float f2 = 3e2; // 3 * 10 ^ 2 
	cout << "f2 = " << f2 << endl;

	//科学计数法表示小数
	float f3 = 3e-2;  // 3 * 0.1 ^ 2
	cout << "f3 = " << f3 << endl;
    
    system("pause");
    return 0;
}

字符型

作用：字符型变量可表示单个字符。
语法：char ch = 'a';

注1：使用单引号表示字符，且单引号内有且仅有1个字符，不可以是字符串。
注2：使用 (int) ch 查询字符对应的ASCII编码。'a’对应97，'A’对应65。

int main()
{
	//字符型变量创建方式
	char ch = 'a';
	cout << ch << endl;

	//字符型变量所占内存大小
	cout << "char字符型变量占用的内存大小：" << sizeof(char) << endl;
	cout << "char字符型变量占用的内存大小：" << sizeof(ch) << endl;

	//字符型变量常见错误
	//char ch2 = "b";		//错误：表示字符时需使用单引号
	//char ch2 = 'abcdef';	//错误：单引号内只能有一个字符

	//字符型变量对应ASCII编码（a：97； A：65）
	cout << (int)ch << endl;
    
    system("pause");
    return 0;
}

ASCII码表格：

ASCII值控制字符ASCII值字符ASCII值字符ASCII值字符
0NUT32(space)64@96、
1SOH33!65A97a
2STX34"66B98b
3ETX35#67C99c
4EOT36$68D100d
5ENQ37%69E101e
6ACK38&70F102f
7BEL39,71G103g
8BS40(72H104h
9HT41)73I105i
10LF42*74J106j
11VT43+75K107k
12FF44,76L108l
13CR45-77M109m
14SO46.78N110n
15SI47/79O111o
16DLE48080P112p
17DCI49181Q113q
18DC250282R114r
19DC351383S115s
20DC452484T116t
21NAK53585U117u
22SYN54686V118v
23TB55787W119w
24CAN56888X120x
25EM57989Y121y
26SUB58:90Z122z
27ESC59;91[123{
28FS60<92/124|
29GS61=93]125}
30RS62>94^126`
31US63?95_127DEL

ASCII 码的大致组成部分：

  • 非打印控制字符：ASCII 表的 数字0-31 分配给控制字符，用于控制如打印机等外围设备。
  • 打印字符：ASCII 表的 数字32-126 分配给键盘上的字符。

转义字符

作用：表示一些特殊的无法直接显示的ASCII字符。
常用的转义字符有：\n \\ \t

注1：C语言中使用转义字符\n换行，C++中使用endl换行。
注2：表示水平制表符的转义符\t占据8个字符宽度。

转义字符含义ASCII码值（十进制）
\a警报007
\b退格(BS) ，将当前位置移到前一列008
\f换页(FF)，将当前位置移到下页开头012
\n换行(LF) ，将当前位置移到下一行开头010
\r回车(CR) ，将当前位置移到本行开头013
\t水平制表(HT) （跳到下一个TAB位置）009
\v垂直制表(VT)011
\\代表一个反斜线字符“\”092
\’代表一个单引号（撇号）字符039
\"代表一个双引号字符034
\?代表一个问号063
\0数字0000
\ddd8进制转义字符，d范围0~73位8进制
\xhh16进制转义字符，h范围0-9，a-f，A~F3位16进制
int main()
{
	cout << "\\" << endl;
	cout << "\tHello" << endl;
	cout << "\n" << endl;

    system("pause");
    return 0;
}

字符串型

作用：表示一串字符

  1. C风格字符串： char 变量名[] = "字符串值";
int main()
{
    //C风格字符串
    char str1[] = "hello world";
    cout << str1 << endl;
    
    system("pause");
    return 0;
}

注1：使用C风格字符串时，需使用双引号将字符串值括起来。

注2：char 字符串名 []

  1. C++风格字符串： string 变量名 = "字符串值";
#include <string>

int main()
{
	//C++风格字符串
	string cppStr = "hello cpp str";
	cout << cppStr << endl;
    
    system("pause");  
	return 0;
}

注1：使用C++风格字符串时，需包含头文件#include <string>。

布尔类型 bool

作用：布尔数据类型表示真或假的值。
bool类型只有两个值

  • true — 真（本质是1）
  • false — 假（本质是0）

bool类型占1个字节大小

int main()
{
	bool flag = true;
	cout << flag << endl;	// 1（真）

	/* C++的bool类型中，true 或 任意非0值 均代表“真” */
	flag = 6.66f;
	cout << flag << endl;	// 1（真）

	flag = false;
	cout << flag << endl;	// 0（假）

	/* C++的bool类型中，false 或 0值 代表“假” */
	flag = 0;
	cout << flag << endl;	// 0（假）

	cout << "bool类型占用的内存大小：" << sizeof(bool) << endl;
	cout << "bool类型占用的内存大小：" << sizeof(flag) << endl;

    system("pause");
    return 0;
}

数据的输入

作用：从键盘获取数据

关键字：cin

语法： cin >> 变量

#include <iostream>
using namespace std;

#include <string>

int main()
{
    //1、整型
    int a = 0;
    cout << "请给整型变量a赋值：" << endl;
    cin >> a;
    cout << "整型变量a = " << a << endl;
    
    //2、浮点型
    float f = 3.14f;
    cout << "请给浮点型变量f赋值：" << endl;
    cin >> f;
    cout << "浮点型变量f = " << f << endl;

    //3、字符型
    char ch = 'a';
    cout << "请给字符型变量ch赋值：" << endl;
    cin >> ch;
    cout << "字符型变量ch = " << ch << endl;

    //4、字符串型
    string str = "hello";
    cout << "请给字符串型变量str赋值：" << endl;
    cin >> str;
    cout << "字符串型变量str = " << str << endl;

    //5、布尔类型
    bool flag = false;
    cout << "请给布尔类型 flag 赋值：" << endl;
    cin >> flag;//bool类型 只要非0的值都代表真
    cout << "布尔类型 flag = " << flag << endl;


    system("pause");
    return 0;
}

运算符

算术运算符

作用：用于处理四则运算

请添加图片描述

注1：两整数相除，结果依然是整数，将小数部分去除

注2：两个数相除，除数是不可以为0的

注3：两小数可以相除，运算结果可以是小数

注4：两个数相除除数是不可以为0，所以也做不了取模运算

总结：只有整型变量可以进行取模运算

#include <iostream>
using namespace std;


int main()
{
    //1、前置递增
    int a = 10;
    ++a; //让变量+1
    cout << "a = " << a << endl;

    //2、后置递增
    int b = 10;
    b++; //让变量+1
    cout << "b = " << b << endl;

    //3、前置和后置的区别
    //前置运算 先让变量+1，然后进行表达式运算
    int a2 = 10;
    int b2 = ++a2 * 10;
    cout << "a2 = " << a2 << endl;
    cout << "b2 = " << b2 << endl;

    //后置运算 先进行表达式运算，后让变量+1
    int a3 = 10;
    int b3 = a3++ * 10;
    cout << "a3 = " << a3 << endl;
    cout << "b3 = " << b3 << endl;

    system("pause");
    return 0;
}

总结：前置递增先对变量进行++，再计算表达式，后置递增相反

赋值运算符

作用：用于将表达式的值赋给变量

在这里插入图片描述

比较运算符

在这里插入图片描述

优先级加括号，不然报错

逻辑运算符

在这里插入图片描述

程序流程结构

c++中支持最基本的三种流程结构：顺序结构、选择结构、循环结构

  • 顺序结构：程序按顺序执行，不会发生跳转。
  • 选择结构：根据条件是否满足，有选择的执行相应的功能。
  • 循环结构：根据条件是否满足，循环多次执行某代码块。

选择结构

if语句

作用：执行满足条件的语句

  • 单行格式if语句
  • 多行格式if语句
  • 多条件的if语句
  1. 单行格式if语句：if(条件){ 条件满足执行的语句 }
Created with Raphaël 2.3.0 开始 判断条件 执行语句 结束 yes no 
#include<iostream>
using namespace std;

int main()
{
	//选择结构 单行if语句
	//用户输入考试分数，如果分数大于600，则视为考上一本大学，在屏幕上输出
    
	//1.用户输入分数
    int score = 0;
	cout << "请输入考试分数：" << endl;
	cin >> score;

	//2.打印用户输入的分数
	cout << "您输入的分数为：" << score << endl;

	//3.判断分数是否大于600，如果大于则输出考上一本大学
	//注意事项，if条件后面不要加分号
	if (score > 600)
	{
		cout << "恭喜您考上一本大学" << endl;
	}

	system("pause");
	return 0;
}
  1. 多行格式if语句：if(条件){ 条件满足执行的语句 }else{ 条件不满足执行的语句 }；
Created with Raphaël 2.3.0 开始 判断条件 执行语句1 结束 执行语句2 yes no 
#include<iostream>
using namespace std;

int main()
{
	//选择结构 - 多行if语句
	//用户输入考试分数，如果分数大于600，则视为考上一本大学，在屏幕上输出
	//如果没有考上一本大学，则打印未考上一本大学

	//1.输入考试分数
	int score = 0;
	cout << "请输入考试分数：" << endl;
	cin >> score;

	//2.提示用户输入的分数
	cout << "您输入的分数为：" << score << endl;

	//3.判断 如果大于600，打印考上一本，否则打印未考上一本
	if (score > 600) //大于600分执行下面大括号中的内容
	{
		cout << "恭喜您考上一本大学！" << endl;
	}
	else //不大于600分，执行else后大括号中的内容
	{
		cout << "您未考上一本大学" << endl;
	}
    
	system("pause");
	return 0;
}
  1. 多条件的if语句：if(条件1){ 条件1满足执行的语句 }else if(条件2){ 条件2满足执行的语句 }...else{ 都不满足执行的语句 }

在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	// 选择结构 多条件if语句
	// 输入一个考试分数，如果大于600，则视为考上一本大学，在屏幕输出
	// 大于500，视为考上二本大学，屏幕输出
	// 大于400，视为考上三本大学，屏幕输出
	// 小于等于400分，视为未考上本科，屏幕上输出

	// 1.用户输入分数
	int score = 0;
	cout << "请输入考试分数：" << endl;
	cin >> score;

	// 2.打印用户输入的分数
	cout << "您输入的分数为：" << score << endl;

	// 3.判断
	// 如果大于600，考上一本
	// 如果大于500，考上二本
	// 如果大于400，考上三本
	// 前三个都没有满足，未考上本科
	if (score > 600)
	{
		cout << "您考上一本大学" << endl;
	}
	else if (score > 500) //第二个条件判断
	{
		cout << "您考上二本大学" << endl;
	}
	else if (score >= 400) //第三个条件判断
	{
		cout << "您考上三本大学" << endl;
	}
	else
	{
		cout << "未考上本科大学，请再接再厉" << endl;
	}

	system("pause");
	return 0;
}

嵌套if语句：在if语句中，可以嵌套使用if语句，达到更精确的条件判断

案例需求：

  • 提示用户输入一个高考考试分数，根据分数做如下判断
  • 分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；
  • 在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。
#include<iostream>
using namespace std;

int main()
{
	/*
	-提示用户输入一个高考考试分数，根据分数做如下判断
	- 分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科；
	- 在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大。
	*/

	//1.提示输入高考分数
	int score = 0;
	cout << "请输高考考试分数：" << endl;
	cin >> score;

	//2.显示高考分数
	cout << "您输入的分数为：" << score << endl;

	//3.判断
	// 如果大于600 一本
		// 大于700 北大
		// 大于650 清华
		// 其余 人大
	// 如果大于500 二本
	// 如果大于400 三本
	// 其余情况 未考上本科
	
	if (score >= 600)
	{
		cout << "恭喜您考入一本大学" << endl;
		if (score >= 700)
		{
			cout << "您考上北大" << endl;
		}
		else if (score >= 650)
		{
			cout << "您考上清华" << endl;
		}
		else
		{
			cout << "您考上人大" << endl;
		}
	}
	else if (score >= 500)
	{
		cout << "您考上二本大学" << endl;
	}
	else if (score >= 400)
	{
		cout << "您考上三本大学" << endl;
	}
	else
	{
		cout << "您未考上本科大学" << endl;
	}

	system("pause");
	return 0;
}

练习案例：三只小猪称体重

有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重?

在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	//三只小猪称体重,判断哪只最重

	//1、创建三只小猪的体重变量
	int num1 = 0;
	int num2 = 0;
	int num3 = 0;

	//2、让用户输入三只小猪的重量
	cout << "请输入小猪A的体重" << endl;
	cin >> num1;
	
	cout << "请输入小猪B的体重" << endl;
	cin >> num2;

	cout << "请输入小猪C的体重" << endl;
	cin >> num3;


	cout << "A小猪的体重是：" << num1 << endl;
	cout << "B小猪的体重是：" << num2 << endl;
	cout << "C小猪的体重是：" << num3 << endl;
	//判断哪只最重
	//先判断A与B的重量
	if (num1 > num2) //A比B重
	{
		if (num1 > num3) //A比C重
		{
			cout << "小猪A最重" << endl;
		}
		else //C比A重
		{
			cout << "小猪C最重" << endl;
		}
	}
	else  //B比A重
	{
		if (num2 > num3) //B比C重
		{
			cout << "小猪B最重" << endl;
		}
		else //C比B重
		{
			cout << "小猪C最重" << endl;
		}
	}

	system("pause");
	return 0;
}
三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1 ? 表达式2 : 表达式3

解释：

如果表达式1值为真，执行表达式2，并返回表达式2的结果
如果表达式1值为假，执行表达式3，并返回表达式3的结果

#include<iostream>
using namespace std;

int main()
{
	//三目运算符

	//创建三个变量 a b c
	//将a和b作比较，将变量大的值赋值给变量c

	int a = 10;
	int b = 20;
	int c = 0;

	c = (a > b ? a : b);

	cout << "c = " << c << endl;

	//在c++中三目运算符返回的是变量，可以继续赋值
	(a < b ? a : b) = 100;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}
switch语句

作用：执行多条件分支语句

语法：

switch(表达式)
{
        
    case 结果1: 执行语句；break;
        
    case 结果1: 执行语句；break;
        
    ···
            
    default: 执行语句;break;
        
}

#include<iostream>
using namespace std;

int main()
{
	//switch语句
	//给电影进行打分
	//10-9 经典
	//8-7 非常好
	//6-5 一般
	//5以下 烂片

	//1.提示用户给电影进行评分
	cout << "请给电影进行打分" << endl;

	//2.用户开始进行打分
	int score = 0;
	cin >> score;
	cout << "您打的分数为：" << score <<endl;

	//3.根据用户输入的分数来提示用户最后输入的结果
	switch (score)
	{
	case 10:
		cout << "您认为是经典电影" << endl;
		break; //退出当前分支
	case 9:
		cout << "您认为是经典电影" << endl;
		break;
	case 8:
		cout << "您认为电影非常好" << endl;
		break;
	case 7:
		cout << "您认为电影非常好" << endl;
		break;
	case 6:
		cout << "您认为电影一般" << endl;
		break;
	case 5:
		cout << "您认为电影一般" << endl;
		break;
	default:
		cout << "您认为这个电影是烂片" << endl;
		break;
	}

	//if and switch 区别？
	//switch缺点：判断的时候只能是整型或者是字符型，不可以是一个区间
	//switch优点：结构清晰，执行效率高

	system("pause");
	return 0;
}

循环结构

while循环语句

作用：满足循环条件，执行循环语句

语法：while(循环条件){ 循环语句 }

解释：只要循环条件的结果为真，就执行循环语句

#include <iostream>
using namespace std;

int main()
{
	//while循环
	//在屏幕中打印0-9这10个数字
	/*int num = 0;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;

	num++;
	cout << num << endl;*/

	int num = 0;

	//while()中填入循环条件
	//注意事项：在写循环一定要避免死循环出现
	while (num < 10)
	{
		cout << num << endl;
		num++;
	}

	system("pause");
	return 0;
}

注意事项：在执行循环语句时候，程序必须提供跳出循环的出口，否则出现死循环

while循环练习案例：猜数字

案例描述：系统随机生成一个1到100以内的数字，玩家进行猜测，如果猜错，提示玩家数字过大或者数字过小，如果猜对恭喜玩家胜利，并且退出游戏。

在这里插入图片描述

#include <iostream>
using namespace std;
//time系统时间头文件包含
#include <ctime>

int main()
{

	//添加随机数种子 作用利用当前系统时间生成随机数，防止每次随机数都一样
	srand((unsigned int)time(NULL));

	//1、系统生成随机数
	int num = rand() % 100 + 1;  //rand()%100 + 1 生成 0 + 1 - 99 + 1 随机数
	//cout << num << endl;

	//2、玩家进行猜测
	int val = 0;
	
	while (1)
	{
		cin >> val;

		//3、判断玩家的猜测

		//猜错 提示猜的结果 过大或者过小 重新返回第2步

		if (val > num)
		{
			cout << "猜测过大" << endl;
		}
		else if (val < num)
		{
			cout << "猜测过小" << endl;
		}
		else
		{
			cout << "恭喜您猜对了" << endl;
			//猜对 退出游戏
			break; //break在循环中，可以利用该关键字来退出当前循环
		}
	}

	system("pause");
	return 0;
}
do…while循环语句

作用：满足判断条件，执行循环语句

语法：do{ 循环语句 }while(循环条件)；

注意：与while的区别是do…while会先执行一次循环语句，再去判断循环条件

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	//do...while语句
	//在屏幕中输出0-9这10个数字

	int num = 0;
	
	do
	{
		cout << num << endl;
		num++;
	} while (num < 10);

	/*while (num < 10)
	{
		cout << num << endl;
		num++;
	}*/

	//do...while与while的区别是do...while会先执行一次循环语句 ，再去判断循环条件

	system("pause");
	return 0;
}

练习案例：水仙花数

案例描述：水仙花数是一个3位数，他的每个位上的数字的3次幂之和等于它本身。

例如： 1 3 + 5 3 + 3 3 = 153 1^3+5^3+3^3=153 13+53+33=153

请利用do…while语句，求出所有3位数中的水仙花数

思路：

1、将所有的三位数进行输出（100-999）

2、在所有三位数中找到水仙花数

​ 水仙花数 153

​

​ 获取个位 153 % 10 = 3 对数字取模于10 可以获取到个位

​ 获取十位 153 /10 = 15 15 % 10 = 5 先整除于10，得两位数，再取模于10，得到十位

​ 获取百位 153 / 100 = 1 直接整除于100，获得百位

​

​ 判断 个位 3 + 十位 3 + 百位 3 = 本身 {个位}^3+{十位}^3+{百位}^3=本身 个位3+十位3+百位3=本身

#include <iostream>
using namespace std;

int main()
{

	//1、先打印所有三位数字
	int num = 100;

	do
	{
		//2、从所有三位数字中找到水仙花数
		int a = 0;//个位
		int b = 0;//十位
		int c = 0;//百位

		a = num % 10;//获取数字的个位
		b = num / 10 % 10;//获取数字的十位
		c = num / 100;//获取数字的百位

		if (a*a*a + b*b*b + c*c*c == num)//如果是水仙花数，才打印
		{
			cout << num << endl;
		}
		num++;
	} while (num < 1000);

	system("pause");
	return 0;
}
for循环语句

作用：满足循环条件，执行循环语句

语法：for(起始表达式;条件表达式;末尾循环体){ 循环语句; }

#include <iostream>
using namespace std;

int main()
{
	//for循环
	//从数字0 打印到 数字9
	/*for (int i = 0; i < 10; i++ )
	{
		cout << i << endl;
	}*/
	int i = 0;
	for (; ; )
	{
		if (i >= 10)
		{
			break;
		}
		cout << i << endl;
		i++;
	}

	system("pause");
	return 0;
}

注意：for循环中的表达式，要用分号进行分隔

总结：while，do…while,for都是开发中常用的循环语句，for循环结构比较清晰，比较常用

联系案例：敲桌子

案例描述：从1开始数到数字100，如果数字个位含有7，或者十位含有7，或者是7的倍数，我们打印敲桌子，其余数字直接打印输出。

1、先输出1到100 这些数字

2、从这100个数字中找到特殊数字，改为“敲桌子”

​ 特殊数字

​

​ 7的倍数 (7 14 21 28 …) % 7 = 0

​ 个位有7 (7 17 27 37 …) % 10 = 7

​ 十位有7 (70 71 72 73 …) / 10 =7

#include <iostream>
using namespace std;

int main()
{
	for (int i = 1; i <= 100; i++ )
	{
		if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7)
		{
			cout << "敲桌子" << endl;
		}
		else
		{
			cout << i << endl;
		}
	}

	system("pause");
	return 0;
}
4.2.4 嵌套循环

作用：在循环体中再去嵌套一层循环，解决一些实际的问题

例如我们想在屏幕中打印如下图片，就需要利用嵌套循环

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	//利用嵌套循环实现星图

	//打印一行星图

	//外层执行一次，内层执行一周
	//外层循环
	for (int i = 0; i < 10; i++)
	{
		//内层循环
		for (int j = 0; j < 10; j++)
		{
			cout << "* ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

练习案例：乘法口诀表

案例描述：利用嵌套循环，实现九九乘法表

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	//乘法口诀表

	//打印行数
	for (int i = 1; i <= 9; i++)
	{
		//cout << i << endl;
		for (int j = 1; j <= i; j++)
		{
			cout << j << "*" << i << "=" << j*i << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

4.3 跳转语句

4.3.1 break语句

作用：用于跳出选择结构或者循环语句

break使用的时机：

  • 出现在switch条件语句中，作用是终止case并且跳出switch
  • 出现在循环语句中，作用是跳出当前的循环语句
  • 出现在嵌套循环中，跳出最近的内层循环语句
#include <iostream>
using namespace std;

int main()
{
	//break的使用时机

	1、出现在switch语句中
	//cout << "请选择副本难度" << endl;
	//cout << "1、普通" << endl;
	//cout << "2、中等" << endl;
	//cout << "3、困难" << endl;

	//int select = 0;//创建选择结果的变量

	//cin >> select;//等待用户输入

	//switch (select)
	//{
	//case 1:
	//	cout << "您选择的是普通难度" << endl;
	//	break;//退出switch语句
	//case 2:
	//	cout << "您选择的是中等难度" << endl;
	//	break;
	//case 3:
	//	cout << "您选择的是困难难度" << endl;
	//	break;
	//default:
	//	break;
	//}

	2、出现在循环语句中
	//for (int i = 0; i < 10; i++)
	//{
	//	//如果i等于5，退出循环，不再打印
	//	if (i == 5)
	//	{
	//		break;//退出循环
	//	}
	//	cout << i << endl;
	//}

	//3、出现在嵌套循环语句中
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			if (j == 5)
			{
				break;//退出内层循环
			}
			cout << "* " ;
		}
		cout << endl;
	}

	system("pause");
	return 0;
}
4.3.2 continue语句

作用：在循环语句中，跳过本次的循环中余下尚未执行的语句，继续执行下一次循环

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	//continue语句

	for (int i = 0; i <= 100; i++)
	{
		//如果是奇数输出，偶数不输出
		if (i % 2 == 0)//0 2 4 6 8 10
		{ 
			continue;//可以筛选条件，执行到此就不在执行，执行下一次循环，如果是break会退出循环。
		}
		cout << i << endl;
	}

	system("pause");
	return 0;
}
4.3.3 goto语句

作用：可以无条件的跳转语句

语法：goto 标记;

解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置。

1 xxxxx

2 xxxxx

​ goto FLAG;

3 xxxxx

​

4 xxxxx

FLAG:

5 xxxxx

会跳过三四到标记执行后面语句

#include <iostream>
using namespace std;

int main()
{
	//goto语句

	cout << "1、xxxx" << endl;

	cout << "2、xxxx" << endl;

	goto FLAG;

	cout << "3、xxxx" << endl;

	cout << "4、xxxx" << endl;

	FLAG:
	cout << "5、xxxx" << endl;

	system("pause");
	return 0;
}

注意：在程序中不建议使用goto语句，以免造成程序混乱

5. 数组

5.1 概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素。

特点1：数组中的每个数据元素都是相同的数据类型

特点2：数组是由连续的内存位置组成的。

5.2 一维数组

5.2.1 一维数组定义方式

一维数组的三种定义方法：

  1. 数据类型 数组名[ 数组长度 ];

  2. 数据类型 数组名[ 数组长度 ] = { 值1, 值2 ...};

  3. 数据类型 数组名[ ] = { 值1, 值2, ...};

#include <iostream>
using namespace std;

int main()
{
	//数组

	/*
	1. 数据类型 数组名[ 数组长度 ];
	2. 数据类型 数组名[ 数组长度 ] = { 值1, 值2 ...};
	3. 数据类型 数组名[ ] = { 值1, 值2, ...};
	*/

	//1. 数据类型 数组名[ 数组长度 ];
	int arr[5];
	//给数组中的元素进行赋值
	arr[0] = 10;
	arr[1] = 20;
	arr[2] = 30;
	arr[3] = 40;
	arr[4] = 50;

	//访问数据元素
	cout << arr[0] << endl;
	cout << arr[1] << endl;
	cout << arr[2] << endl;
	cout << arr[3] << endl;
	cout << arr[4] << endl;


	//2. 数据类型 数组名[数组长度] = { 值1, 值2 ... };
	//如果在初始化数据时候，没有全部填写完，会用0来填补剩余数据
	int arr2[5] = { 10, 20, 30, 40, 50 };
	/*
	cout << arr2[0] << endl;
	cout << arr2[1] << endl;
	cout << arr2[2] << endl;
	cout << arr2[3] << endl;
	cout << arr2[4] << endl;
	*/
	//利用循环 输出数组中的元素
	for (int i = 0; i < 5; i++)
	{
		cout << arr2[i] << endl;
	}


	//3. 数据类型 数组名[] = { 值1, 值2, ... };
	//定义数组的时候，必须有初始长度
	int arr3[] = { 90, 80, 70, 60, 50, 40, 30, 20, 10 };
	for (int i = 0; i < 9; i++)
	{
		cout << arr3[i] << endl;
	}


	system("pause");
	return 0;
}

.

5.2.2 一维数组数组名

一维数组的名称的用途：

  1. 可以统计整个数组在内存中的长度

  2. 可以获取数组在内存中的首地址

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	//数组名用途
	//1. 可以通过数组名称统计整个数组占用内存大小
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	cout << "整个数组占用内存大小：" << sizeof(arr) << endl;
	cout << "整个元素占用内存大小：" << sizeof(arr[0]) << endl;
	cout << "数组中元素个数为：" << sizeof(arr) / sizeof(arr[0]) << endl;

	//2. 可以通过数组名查看数组首地址
	cout << "数组首地址为：" << arr << endl;
	cout << "数组首地址(转十进制)为：" << (int) arr << endl;
	//arr[0]是第一个元素，想看地址前面加一个&
	cout << "数组中第一个元素地址为：" << &arr[0] << endl;
	cout << "数组中第一个元素地址(转十进制)为：" << (int) &arr[0] << endl;
	cout << "数组中第二个元素地址(转十进制)为：" << (int)&arr[1] << endl;

	// 数组名是常量，不可以进行赋值操作
	//arr = 100;

	system("pause");
	return 0;
}

练习案例1：五只小猪称体重

案例描述：

在一个数组中记录了五只小猪的体重，如int arr[5] = { 300, 350, 200, 400, 250};找出并打印最重的小猪的体重。

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	//1、创建5只小猪体重的数组
	int arr[5] = { 300, 350, 200, 400, 250 };

	//2、从数组中找到最大值
	int max = 0;//先认定一个最大值为0
	for (int i = 0; i < 5; i++)
	{
		//cout << arr[i] << endl;
		//如果访问的数组中的元素比我认定的最大值还有大，更新最大值|
		if (arr[i] > max)
		{
			max = arr[i];
		}
	}

	//3、打印最大值
	cout << "最重的小猪体重为：" << max << endl;

	system("pause");
	return 0;
}

练习案例2：数组元素逆置

案例描述：请声明一个5个元素的数组，并且将元素逆置。

(如原数组元素为：1,3,2,5,4； 逆置后的输出结果：4,5,2,3,1)；
在这里插入图片描述
在这里插入图片描述

5.2.3 冒泡排序

作用：最常用的排序算法，对数组内的元素进行排序

  1. 比较相邻的元素，如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素做相同的工作，执行完毕后，找到第一个最大值。
  3. 重复以上的步骤，每一次比较次数-1，直到不需要比较。

在这里插入图片描述

排序总轮数 = 元素个数 - 1；

每轮对比次数 = 元素个数 - 排序轮数 - 1；

#include <iostream>
using namespace std;

int main()
{
	//利用冒泡排序实现升序序列
	int arr[] = { 4, 2, 8, 0, 5, 7, 1, 3, 9 };

	cout << "排序前：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	//开始冒泡排序
	//总共排序轮数为 元素个数 - 1
	for (int i = 0; i < 9 - 1; i++)
	{
		//内层循环对比	次数 = 元素个数 - 当前轮数 - 1
		for (int j = 0; j < 9 - 1; j++)
		{
			//如果第一个数字，比第二个数字大，交换两个数字
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}

	//排序后结果
	cout << "排序后：" << endl;
	for (int i = 0; i < 9; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}

5.3 二维数组

二维数组就是在一维数组上，多加一个维度。

5.3.1 二维数组的定义方式

二维数组有四种定义方式：

  1. 数据类型 数组名[ 行数 ][ 列数 ];
  2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1, 数据2 } , {数据3, 数据4 } };
  3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};
  4. 数据类型 数组名[ ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};

建议：以上4种定义方式，利用第二种更加直观，提高代码的可读性

在这里插入图片描述

#include <iostream>
using namespace std;

int main()
{
	//二维数组定义方式
	/*
		1. 数据类型 数组名[ 行数 ][ 列数 ];
		2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1, 数据2 } , {数据3, 数据4 } };
		3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};
		4. 数据类型 数组名[ ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};
	*/

	//1. 数据类型 数组名[行数][列数];
	int arr[2][3];
	arr[0][0] = 1;
	arr[0][1] = 2;
	arr[0][2] = 3;
	arr[1][0] = 4;
	arr[1][1] = 5;
	arr[1][2] = 6;

	//外层循环打印行数，内层循环打印列数
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr[i][j] << " ";
		}
		cout << endl;
	}

	//2. 数据类型 数组名[行数][列数] = { {数据1, 数据2 } , {数据3, 数据4 } };
	int arr2[2][3] = 
	{ 
		{1, 2, 3}, 
		{4, 5, 6}
	};
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr2[i][j] << " ";
		}
		cout << endl;
	}

	//3. 数据类型 数组名[行数][列数] = { 数据1, 数据2, 数据3, 数据4 };
	int arr3[2][3] = { 1, 2, 3, 4, 5, 6 };
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr3[i][j] << " ";
		}
		cout << endl;
	}

	//4. 数据类型 数组名[][列数] = { 数据1, 数据2, 数据3, 数据4 };
	int arr4[][3] = { 1, 2, 3, 4, 5, 6 };
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr4[i][j] << " ";
		}
		cout << endl;
	}

	system("pause");
	return 0;
}

总结：在定义二维数组时，如果初始化了数据，可以省略行数

5.3.2 二维数组数组名
  • 查看二维数组所占的内存空间
  • 获取二维数组的首地址
#include<iostream>
using namespace std;

int main()
{
	//二维数组的名称用途

	//1.可以查看占用的内存空间大小
	int arr[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	double arr2[2][3] =
	{
		{1,2,3},
		{4,5,6}
	};

	cout << "二维数组(int)占用的内存空间为：" << sizeof(arr) << endl;
	cout << "二维数组(double)占用的内存空间为：" << sizeof(arr2) << endl;
	cout << "二维数组第一行占用的内存空间为：" << sizeof(arr[0]) << endl;
	cout << "二维数组第一个元素占用内存为：" << sizeof(arr[0][0]) << endl;
	cout << "二维数组行数为：" << sizeof(arr) / sizeof(arr[0]) << endl;
	cout << "二维数组列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
	
	//2.可以查看二维数组的首地址
	cout << "二维数组的首地址为" << (int)arr << endl;
	cout << "二维数组第一行的首地址为：" << (int)arr[0] << endl;
	cout << "二维数组第二行的首地址为：" << (int)arr[1] << endl;

	cout << "二维数组第一个元素的首地址为：" << (int)&arr[0][0] << endl;
	cout << "二维数组第二个元素的首地址为：" << (int)&arr[0][1] << endl;
	 
	system("pause");
	return 0;
}
5.3.3 二维数组应用案例

考试成绩统计：

案例描述：有三名同学(张三，李四，王五)，在一次考试中的成绩分别如下表，请分别输出三位同学的总成绩

语文数学英语
张三100100100
李四9050100
王五607080

1、创建二维数组：3行3列

2、统计考试成绩，让每行的3列相加，统计总和

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

int main()
{
	//二维数组案例-考试成绩统计

	//1、创建二维数组
	int scores[3][3] =
	{
		{100,100,100},
		{90,50,100},
		{60,70,80}
	};

	string names[3] = { "张三","李四","王五" };

	//2、统计每一人的总和分数
	for (int i = 0; i < 3; i++)
	{
		int sum = 0;//统计分数总和变量
		for (int j = 0; j < 3; j++)
		{
			sum += scores[i][j];
			cout << scores[i][j] << "\t";
		}
		cout << names[i] << "的总分为" << sum << endl;
	}

	system("pause");
	return 0;
}

6. 函数

6.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每一个模块实现特定的功能。

6.2 函数的定义

函数的定义一般主要有5个步骤：

  1. 返回值类型：一个函数可以返回一个值。在函数定义中
  2. 函数名：给函数起个名
  3. 参数列表：使用该函数时，传入的数据
  4. 函数体语句：花括号内的代码，函数内需要执行的语句
  5. return表达式：和返回值类型挂钩，函数执行完后，返回相应的数据

语法:

返回值类型 函数名 (参数列表)
{
    函数体语句
        
    return表达式
}

示例：定义一个加法函数，实现两个数相加

实现一个加法运算，功能是传入两个整型数据，计算数据相加的结果，并且返回

1、返回值类型 int

2、函数名 add

3、参数列表 (int num1, int num2)

4、函数体语句 int sum = num1 + num2;

5、return表达式 return sum;

int add(int num1, int num2)
{
    int sum = num1 + num2;
    return sum;
}

6.3 函数的调用

#include<iostream>
using namespace std;

//定义加法函数
//函数定义的时候，num1和num2并没有真实数据
//他只是一个形式上的参数，简称为形参
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

int main()
{
	//main函数中调用add函数
	int a = 10;
	int b = 20;

	//函数调用语法：函数名称 (参数)
	//a和b称为 实际参数， 简称实参
	//当调用函数的时候，实参会把值传递给形参
	int c = add(a, b);

	cout << "c = " << c << endl;

	a = 100;
	b = 500;

	c = add(a, b);

	cout << "c = " << c << endl;

	system("pause");
	return 0;
}

6.4 值传递

  • 所谓值传递，就是函数调用时实参将数值传入给形参
  • 值传递时，如果形参发生改变，并不会影响实参
#include<iostream>
using namespace std;

//值传递
//定义函数，实现两个数字进行交换函数

//如果函数不需要返回值，声明的时候可以写void

void swap(int num1, int num2)
{
	cout << "交换前" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "交换前" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;

	//return;	返回值不需要的时候，可以不写return
}

int main()
{
	int a = 10;
	int b = 20;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	//当我们做值传递的时候，函数的形参发生改变，并不会影响实参
	swap(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

值传递学习

总结：值传递时，形参是修饰不了实参的

6.5 函数的常见样式

  1. 无参无返
  2. 有参无返
  3. 无参有返
  4. 有参有返
#include<iostream>
using namespace std;

//函数常见样式
//1. 无参无返
void test01()
{
	cout << "this is test01" << endl;
}

//2. 有参无返
void test02(int a)
{
	cout << "this is test02 a = " << a << endl;
}

//3. 无参有返
int test03()
{
	cout << "this is test03 " << endl;
	return 1000;
}

//4. 有参有返
int test04(int a)
{
	cout << "this is test042 a = " << a << endl;
	return a;
}


int main()
{
	//无参无返函数调用
	test01();

	//有参无返函数调用
	test02(100);

	//无参有返函数调用
	int num1 = test03();
	cout << "num1 = " << num1 << endl;

	//有参有返函数调用
	int num2 = test04(10000);
	cout << "num2 = " << num2 << endl;

	system("pause");
	return 0;
}

6.6 函数的声明

作用：告诉编译器函数名称以及如何调用函数。函数的实际主体可以单独定义。

  • 函数的声明可以多次，但是函数的定义只能有一次。
#include<iostream>
using namespace std;

//函数的声明
//比较函数，实现两个整型数字进行比较，返回较大的值

//提前告诉编译器函数的存在，可以利用函数的声明
//函数的声明
int max(int a, int b);//声明可以写多次，但是定义函数只能有一次

定义
//int max(int a, int b)
//{
//	return a > b ? a : b;
//}

int main()
{
	int a = 10;
	int b = 20;
	cout << max(a, b) << endl;

	system("pause");
	return 0;
}

//定义
int max(int a, int b)
{
	return a > b ? a : b;
}

6.7 函数分文件编写

作用：让代码结构更加清晰

函数分文件编写有四个步骤：

  1. 创建后缀名为.h的头文件
  2. 创建后缀名为.cpp的源文件
  3. 在头文件中写函数的声明
  4. 在源文件中写函数的定义
#include<iostream>
using namespace std;
#include "swap.h"

//函数的分文件编写
//实现两个数字进行交换的函数

函数的声明
//void swap(int a, int b);
//函数的定义
//void swap(int a, int b)
//{
//	int temp = a;
//	a = b;
//	b = temp;
//
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//}

//1. 创建后缀名为.h的头文件
//2. 创建后缀名为.cpp的源文件
//3. 在头文件中写函数的声明
//4. 在源文件中写函数的定义

int main()
{
	int a = 10;
	int b = 20;

	swap(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

swap.h头文件：

#include <iostream>
using namespace std;

//函数的声明
void swap(int a, int b);

swap.cpp源文件：

#include "swap.h"

void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

7. 指针

7.1 指针的基本概念

指针的作用：可以通过指针间接访问内存

  • 内存编号是从0开始记录的，一般用十六进制数字表示
  • 可以利用指针变量保存地址

7.2 指针变量的定义和使用

指针变量定义语法： 数据类型 *变量名;

指针变量的定义与使用

在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	//1、定义一个指针
	int a = 10;
	//指针定义的语法：数据类型 * 指针变量;
	int * p;
	//让指针记录变量a的地址
	p = &a;
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;


	//2、如何使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加 * 代表解引用，找到指针指向的内存中的数据
	*p = 1000;
	cout << "a = " << a << endl;
	cout << "*p = " << *p << endl;

	system("pause");
	return 0;
}

7.3 指针所占内存空间

提问：指针也是种数据类型，那么这种数据类型占用多少内存空间?

在这里插入图片描述

#include<iostream>
using namespace std;

int main()
{
	//	指针所占的内存空间
	int a = 10;
	//int * p;
	//p = &a;

	int * p = &a;

	cout << "sizeof (int *) = " << sizeof(p) << endl;
	cout << "sizeof (int *) = " << sizeof(int *) << endl;
	cout << "sizeof (int *) = " << sizeof(float*) << endl;
	cout << "sizeof (int *) = " << sizeof(double*) << endl;
	cout << "sizeof (int *) = " << sizeof(char*) << endl;
	cout << "sizeof (int *) = " << sizeof(bool*) << endl;

	//在32位操作系统下，指针占4个字节，在64位操作系统下，指针占8个字节。
	
	system("pause");
	return 0;
}

7.4 空指针和野指针

空指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

示例1：空指针

#include<iostream>
using namespace std;

int main()
{
	//空指针
	//1.空指针用于给指针变量进行初始化
	int * p = NULL;

	//2.空指针是不可以进行访问的
	//0-255之间的内存编号是系统占用的，因此不可以访问
	//*p = 100;
	
	system("pause");
	return 0;
}
空指针

空指针：指针指向非法的内存空间。

#include<iostream>
using namespace std;

int main()
{
	//野指针
	//在程序中，尽量避免出现野指针
	int * p = (int *)0x1100;
	//cout << *p << endl;
    
	system("pause");
	return 0;
}

总结：空指针和野指针都不是我们申请的空间，因此不要访问。

7.5 const修饰指针

const修饰指针有三种情况：

  1. const修饰指针 —常量指针
  2. const修饰常量 —指针常量
  3. const即修饰指针，又修饰常量

const修饰指针

#include<iostream>
using namespace std;

int main()
{
	//1.const修饰指针  常量指针
	int a = 10;
	int b = 10;

	const int * p = &a;
	//指针指向的值不可以改，指针指向可以改
	//*p = 20;//错误，指针指向的值不可以改
	p = &b;//正确，指针指向可以改

	//2.const修饰常量  指针常量
	//指针的指向不可以改，指针指向的值可以改
	int * const p2 = &a;
	*p2 = 100;//正确，指针的指向不可以改
	//p2 = &b;//错误，指针指向的值可以改

	//3.const修饰指针和常量
	const int* const p3 = &a;
	//指针的指向 和指针指向的值 不可以改
	//*p = 100;//错误
	//p = &b;//错误

	system("pause");
	return 0;
}

技巧：看const右侧紧跟着的是指针还是常量，是指针就是常量指针，是常量就是指针常量

7.6 指针和数组

作用：利用指针访问数组中的元素

值传递学习

#include<iostream>
using namespace std;

int main()
{
	//指针和数组
	//利用指针访问数组中的元素

	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	cout << "第一个元素为：" << arr[0] << endl;

	int * p = arr;//arr就是数组首地址

	cout << "利用指针访问第一个元素：" << *p << endl;

	p++;//让指针向后偏移4个字节

	cout << "利用指针访问第二个元素：" << *p << endl;

	cout << "利用指针遍历数组：" << endl; 

	int * p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		//cout << arr[i] << endl;
		cout << *p2 << endl;
		p2++;
	}
	system("pause");
	return 0;
}

7.7 指针与函数

作用：利用指针作为函数的参数，可以修改实参的值

#include<iostream>
using namespace std;

//实现两个数字进行交换
void swap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "swap01 a = " << a << endl;
	cout << "swap01 b = " << b << endl;
}

void swap02(int *p1, int *p2) {
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main() {
	//指针和函数
	//1.值传递
	//不会改变实参的值
	int a = 10;
	int b = 20;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	swap01(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	cout << "---------------------------------" << endl;
	//2.地址传递
	//如果是地址传递，可以修饰实参
	a = 23;
	b = 78;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	swap02(&a, &b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

指针与函数

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

7.8 指针、数组、函数

需求：封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组 int arr[10] = {4,3,6,9,1,2,10,8,7,5};

#include<iostream>
using namespace std;

//冒泡升序排序函数	参数1	数组的首地址	参数2	数组长度	
void bubbleSort(int * arr, int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			//如果arr[j] > arr[j + 1]	交换数字
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组
void printArray(int * arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}

int main()
{
	//1.创建数组
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };

	//数组长度
	int len = sizeof(arr) / sizeof(arr[0]);

	//2.创建函数实现冒泡排序
	bubbleSort(arr, len);

	//3.打印排序后的数组
	printArray(arr, len);

	system("pause");
	return 0;
}

8. 结构体

8.1 结构体的基本概念

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。

8.2 结构体的定义和使用

语法：struct 结构体名 { 结构体成员列表 };

通过结构体创建变量的方式有三种：

  • struct 结构体名 变量名
  • struct 结构体名 变量名 = { 成员1值, 成员2值…};
  • 定义结构体时顺便创建变量
#include <iostream>
using namespace std;
#include <string>

//1、创建学生数据类型	：	学生包括（姓名，年龄，分数）
struct Student
{
	//成员列表

	//姓名
	string name;

	//年龄
	int age;

	//分数
	int score;
    
}s3;//顺便创建一个结构体变量

//2、通过学生类型创建具体学生


int main()
{
	//2.1	struct Student s1
	//struct 关键字可以省略
	Student s1;
	//给s1属性赋值，通过 . 访问结构体变量中的属性
	s1.name = "张三";
	s1.age = 18;
	s1.score = 95;

	cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;

	//2.2	struct Student s2 = { ... }
	struct Student s2 = 
	{
		"李四", 19, 80
	};

	cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;

	//2.3	在定义结构体时顺便创建结构体变量

	s3.name = "王五";
	s3.age = 20;
	s3.score = 60;
	cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;

	system("pause");
	return 0;
}

总结1：定义结构体时的关键字是struct，不可省略

总结2：创建结构体变量时，关键字struct可以省略

总结3:结构体变量利用操作符" . "访问成员

8.3 结构体数组

作用：将自定义的结构体放入数组中方便维护

语法：struct 结构体名 数组名[元素个数] = { {}, {}, {},... {} };

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

//结构体数组
//1、定义结构体
struct Student
{
	//姓名
	string name;

	//年龄
	int age;

	//分数
	int score;

};

int main()
{
	//2、创建结构体数组
	struct Student stuArray[3] =
	{
		{"张三", 18, 95},
		{"李四", 28, 99},
		{"王五", 38, 66}
	};

	//3、给结构体数组中的元素赋值
	stuArray[2].name = "赵六";
	stuArray[2].age = 80;
	stuArray[2].score = 60;
	
	//4、遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << stuArray[i].name 
			 << " 年龄：" << stuArray[i].age 
			 << " 分数：" << stuArray[i].score << endl;
	}

	system("pause");
	return 0;
}

8.4 结构体指针

作用：通过指针访问结构体中的成员

  • 利用操作符->可以通过结构体指针访问结构体属性
#include<iostream>
using namespace std;
#include<string>

//结构体指针

//定义一个学生的结构体
struct student
{
	string name;//姓名
	int age;//年龄
	int score;//分数

};

int main()
{
	//1.创建学生的结构体变量
	struct student s = { "张三",18,100 };

	//2.通过指针直线结构体变量
	struct student * p = &s;

	//3.通过指针访问结构体变量中的数据
	//通过结构体指针 访问结构体属性，需要利用' -> '
	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	
	system("pause");
	return 0;
}

8.5 结构体嵌套结构体

作用：结构体的成员可以是另一个结构体

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

#include<iostream>
using namespace std;
#include<string>
//定义学生结构体
struct student
{
	string name;//姓名
	int age;//年龄
	int score;//分数
};

//定义老师结构体
struct teacher
{
	int id;//教师编号
	string name;//教师姓名
	int age;//年龄
	struct student stu;//学生结构体：辅导的学生
};

int main()
{
	//结构体嵌套结构体
	//创建老师
	teacher t;
	t.id = 10000;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.age = 20;
	t.stu.score = 60;
	cout << "老师姓名：" << t.name << " 老师编号：" << t.id << " 老师年龄：" << t.age 
		<< " 老师辅导的学生姓名：" << t.stu.name << " 学生年龄: " << t.stu.age
		<< " 学生的考试分数：" << t.stu.score << endl;
	
	system("pause");
	return 0;
}

结构体嵌套结构体

8.6 结构体做函数参数

作用：将结构体作为参数向函数中传递

传递方式有两种：

  • 值传递
  • 地址传递
#include<iostream>
using namespace std;
#include<string>

//定义学生的结构体
struct student
{
	//姓名
	string name;
	//年龄
	int age;
	//分数
	int score;
};

//打印学生信息函数

//1.值传递
void printStudent1(struct student s)
{
	s.age = 100;
	cout << "子函数中 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
}

//2.地址传递
void printStudent2(struct student * p)
{
	p->age = 200;
	cout << "子函数中 姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}
int main()
{
	//结构体做函数参数
	//将学生传入一个参数中，打印学生身上的所有信息

	//创建结构体变量
	struct student s;
	s.name = "张三";
	s.age = 20;
	s.score = 85;

	cout << "main函数中打印 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
	
	printStudent1(s);

	cout << "main函数中打印 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;

	printStudent2(&s);

	cout << "main函数中打印 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;

	system("pause");
	return 0;
}

总结：如果不想修改主函数中的数据，用值传递，反之用地址传递

8.7 结构体中const使用场景

作用：用const来防止误操作

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

//const使用场景

struct student
{
	//定义学生的结构体
	string name;//姓名
	int age;//年龄
	int score;//分数
};

值传递：会将实参中的数据拷贝出一份传递给形参，不会出现任何错误
//void printStudents01(student s)
//{
//	//非常占用内存
//	s.age = 150;
//	cout << " 姓名：" << s.name << " 年龄：" << s.age << " 分数：" << s.score << endl;
//}

将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
//void printStudents02(student *s)
//{
//	s->age = 150;
//	cout << " 姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl;
//}

void printStudents03(const student *s)
{
	//s->age = 123;//加入const之后，一旦有修改的操作就会报错，可以防止误操作
	cout << " 姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl;
}
int main()
{
	//1.创建结构体变量
	struct student s = { "张三", 16, 75 };
	//2.通过函数打印结构体变量信息
	//printStudents01(s);

	//printStudents02(&s);
	//cout << "main中张三的年龄为：" << s.age << endl;

	printStudents03(&s);
	
	system("pause");
	return 0;
}

8.8 结构体案例

8.8.1 案例1

案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下

设计学生和老师的结构体，其中在老师的结构体中，有老师的姓名和一个存放5名学生的数组作为成员

学生的成员有姓名、考试分数、创建数组存放3名老师，通过函数给每个老师及所带的学生赋值

最终打印出老师数据以及老师所带的学生的数据

结构体案例

#include<iostream>
using namespace std;
#include<string>
#include<ctime>

//定义学生的结构体
struct Student
{
	//姓名
	string sName;
	//分数
	int score;
};

//定义老师的结构体
struct Teacher
{
	//姓名
	string tName;
	//学生数组
	struct Student sArray[5];
};

//给老师和学生赋值的函数
void allocateSpace(struct Teacher tArray[], int len)
{
	string nameSeed = "ABCDE"; 

	//给老师开始赋值
	for (int i = 0; i < len; i++)
	{
		tArray[i].tName = "Teacher_";
		tArray[i].tName += nameSeed[i];
		//通过循环给每名老师所带的学生进行赋值
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].sName = "Student_";
			tArray[i].sArray[j].sName += nameSeed[j];

			int random = rand() % 61 + 40;//40到100之间随机数

			tArray[i].sArray[j].score = random;
		}
	}
}
void printInfo(struct Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "老师的姓名：" << tArray[i].tName << endl;

		for (int j = 0; j < 5; j++)
		{
			cout << "\t学生的姓名：" << tArray[i].sArray[j].sName <<
				" 考试分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}
int main()
{
	//添加随机数种子
	srand((unsigned int)time(NULL));

	//1.创建三名老师的数组
	struct Teacher tArray[3];

	//2.通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
	int len = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray, len);

	//3.打印所有老师以及所带的学生的信息
	printInfo(tArray, len);

	system("pause");
	return 0;
}
8.8.2 实例2

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别；创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

五名英雄信息如下：

		{"刘备",23,"男"},
		{"关羽",22,"女"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},

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

//1.设计英雄结构体
//英雄结构体
struct Hero
{
	//姓名
	string name;
	//年龄
	int age;
	//性别
	string sex;
};

//冒泡排序，实现年龄升序排列
void bubbleSort(struct Hero heroArray[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			//如果 j 下标的元素年龄 大于 j+1 下标的元素的年龄，交换两个元素
			if (heroArray[j].age > heroArray[j + 1].age)
			{
				struct Hero temp = heroArray[j];
				heroArray[j] = heroArray[j + 1];
				heroArray[j + 1] = temp;
			}
		}
	}
}

//打印排序后的数组的信息
void printHero(struct Hero heroArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "\t姓名：" << heroArray[i].name
			<< " 年龄：" << heroArray[i].age 
			<< " 性别：" << heroArray[i].sex << endl;
	}
}
int main()
{

	//2.创建数组存放5名英雄
	struct Hero heroArray[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"女"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};

	int len = sizeof(heroArray) / sizeof(heroArray[0]);
	
	cout << "排序前打印：" << endl;
	for (int i = 0; i < len; i++)
	{
		cout << "\t姓名：" << heroArray[i].name
			<< " 年龄：" << heroArray[i].age 
			<< " 性别：" << heroArray[i].sex << endl;
	}
	
	
	
	//3.对数组进行排序，按照年龄进行升序排序
	bubbleSort(heroArray, len);

	cout << "排序后打印：" << endl;
	//4.将排序后的结果进行打印输出
	printHero(heroArray, len);

	system("pause");
	return 0;
}

先更新到这里，还没继续学习更新。

星辰之光.
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++——区间DP例题——分配教室
McDonnell_Douglas的博客
01-21 1566
题目描述 大学教授有很多，当然，每个同学都有自己衷心崇拜的教授。 现在有两位教授，教授甲和教授乙。新入学的N位同学们早已耳闻他们的传奇故事。所以，已经衷心地崇拜其中一位了。现在，老师要给他们分配教室。但是，要么保证整个教室都是同一位教授的粉丝，或者两个教授的粉丝人数差不超过 M 。另外，现在 N 位同学排成一排，老师只会把连续一段的同学分进一个教室。老师想知道，至少需要多少个教室。
信息学奥赛一本通（C++版）第一章 C++语言入门
harry04的博客
08-23 398
1000：入门测试题目 【题目描述】 求两个整数的和。 【输入】 一行，两个用空格隔开的整数。 【输出】 两个整数的和。 【输入样例】 2 3 【输出样例】 5 1001：Hello,World! 【题目描述】 编写一个能够输出“Hello,World!”的程序，这个程序常常作为一个初学者接触一门新的编程语言所写的第一个程序，也经常用来测试开发、编译环境是否能够正常工作。 提示：“Hello,World!”中间没空格。 【输入】 无 【输出】 H
计算机算分数的过程,分数计算器 - C++教室 - C++论坛 - 编程论坛
weixin_34604756的博客
07-27 195
已结贴√问题点数：10回复次数：6 分数计算器#includeusing namespace std;class Fraction{private:int f1;//分子int f2;//分母public:Fraction(int i=0,int j=1):f1(i),f2(j){}void gs()//格式函数{int q=f1;int w=f2;int p=q/w;for(;p!...
C++教学 第六课 考试
weixin_57590606的博客
11-02 498
Hello,大家好，学了五课了，到了该考试的时间了 第一题： 小船要远航 题目描述 一艘轮船行驶时间t为3小时，航行的路程s为90千米，请问速度v为多少？ 输入格式 无 输出格式 输出每小时航行多少千米。 输入输出样列 输入样例1： 无 输出样例1： 30 说明 速度等于路程除以时间 第二题: 求和（sum） 题目描述 给定两个整数a、b，输出a+b的值 输入格式 输入文件：sum.in 一行，用一个空格隔开的两
5、分支对比 - 习题解析
m0_46192147的博客
03-28 671
东方 - 分支 - 分支练习部分解析
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 25万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C++基础入门（超详细）
qq_44859533的博客
07-02 5万+
全网很全的C++基础入门，针对每一个概念以及概念之后的代码实现运行结果。可以帮助新手很快上手，也可以帮助老手回顾C++。
C++入门基础（万字详解！！！）
忘忧.
08-15 4万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
C++基础入门
a577715979的博客
01-02 5182
C++入门
C++入门基础
2021dragon的博客
05-22 1万+
文章目录什么是C++?C++的发展史C++关键字(C++98)命名空间C++中的输入和输出缺省参数函数重载引用内联函数auto关键字(C++11)基于范围的for循环(C++11)指针空值nullptr(C++11) 什么是C++?  C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机，20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象) 思想，支持面向对象的程序
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C++基础入门讲义md
07-16
非常详尽的C++入门讲义，很适合初学者
Linux C | 管道open打开方式
I_feige的博客
07-12 356
1.
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 1074
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++ 生成随机字符串
最新发布
m0_56306892的博客
07-15 207
以下是一个示例代码，它使用std::random_device和std::mt19937生成随机字符，并将结果存储在一个字符串中。std::uniform_int_distribution<> distribution(0, max_index - 1) 创建一个均匀分布，以确保生成的随机数在字符集的索引范围内。输出随机字符串: 在主函数中调用generateRandomString生成一个长度为1024的随机字符串，并输出结果。std::random_device rd 用于生成一个随机种子。
C语言 2个日期相关的函数
waterHBO的博客
07-15 141
读代码的过程中，遇到2个日期相关的工具函数， 记录一下。比较日期，计算日期间隔（天数)
05day--C++日期类的实现与取地址运算符的重载
weixin_73863912的博客
07-13 468
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C++客户端Qt开发——QT初识
m0_63596031的博客
07-13 836
②中的代码创建，是在堆上new出来的一块空间，当把对象改成在栈上创建，此时就可以看到运行起来的程序无法显示出helloworld，此时label对象随着构造函数的结束，就销毁了，所以应该把它交给对象树进行管理。在QT Designer中创建一个控件的时候，此时会给这个控件分配一个objectName属性，这个属性的值，要求是在界面中是唯一的，不能和别人重复。Qt的对象树模型是一种递归的结构，其中一个对象可以拥有多个子对象，而每个子对象又可以拥有自己的子对象，以此类推。坐标体系：以左上角为原点（0,0），

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

星辰之光.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值