C++学习全教程（day1:变量和数据类型、运算符、流行控制语句）

一、变量和数据类型

1、变量

2、标识符

3、作用域

4、常量

5、数据类型

1.基本数据类型-整型

2.char类型

3.bool类型

4.浮点类型

5.字面值常量

二、运算符

1、算数运算符

2、赋值运算符

3、复合赋值运算符

4、关系和逻辑运算

1.关系运算符 -------结果是一个bool值

2.逻辑运算符

3.条件运算符

5、位运算符

1.移位运算符

2.位逻辑运算符

三、流程控制语句

1、条件分支

1.if

2.switch

2、循环

1.while

2.do while

3.for

九九乘法表例程：

3、跳转

1.break

2.continue

3.goto

1、输出hello world

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

std::cout流来输出文本信息。其中<<是输出运算符，它用来将文本信息插入到输出流中。"hello world!"是要输出的文本信息，std::endl是表示插入换行符的操作符，它会在输出文本的末尾插入一个换行符，使得输出的文本在控制台上单独占据一行。最终执行该代码会在控制台上输出"hello world!"并换行。

一、变量和数据类型

1、变量

想要使用变量，必须先做“声明”，也就是告诉计算机要用到的数据叫什么名字，同时还要指明保存数据所需要的空间大小。比如: int a;

这里包含两个信息:一个是变量的名字，叫做“a”，它对应着计算机内存中的一个位置;另一个是变量占据的空间大小，这是通过前面的“int”来指明的，表示我们需要足够的空间来存放一个“整数类型”( integer）数据。

变量声明：数据类型变量名；

#include<iostream>
using namespace std;
int main()
{
	int a = 10, b;
	cout << "a = " << a << endl;
	b = 20;
	cout << "b = " << b << endl;

	//cin.get();//等待键盘输入

}

运行结果：

2、标识符

每个变量都有一个名字，就是所谓的“变量名”。在C++中，变量、函数、类都可以有自己专门的名字，这些名字被叫做“标识符”。

标识符由字母、数字和下划线组成;不能以数字开头;标识符是大小写敏感的，长度不限。

例如： int a; char name;

标识符命名要求：

不能使用C++关键字;

不能用连续两个下划线开头，也不能以下划线加大写字母开头，这些被C++保留给标准库使用;

函数体外的标识符，不能以下划线开头;

要尽量有实际意义（不要定义a、b，而要定义name、age);变量名一般使用小写字母;

自定义类名一般以大写字母开头;

如果包含多个单词，一般用下划线分隔，或者将后面的单词首字母大写;

3、作用域

在C++中，有“作用域”(scope）的概念，就是指程序中的某一段、某一部分。一般作用域都是以花括号{}作为分隔的，就像之前我们看到的函数体那样。

同一个名字在本同的作用域中,可以指代不同的实体(变量、函数、类等等)。定义在所有花括号外的名字具有“全局作用域”(global scope)，而在某个花括号内定义的名字具有“块作用域”。一般把具有全局作用域的变量叫做“全局变量”，具有块作用域的变量叫做“局部变量”。

#include<iostream>
using namespace std;

int number = 0;  //全局变量

int main()
{
	int number = 666;  //局部变量
	cout << "number = " << number << endl;
}

全局变量和局部变量同名的时候会输出什么样的结果？可以思考一下哟

输出结果：

为什么输出的是666，而不是0呢？输出结果是以作用域更小的为准，就相当于局部变量覆盖了全局变量。那新的问题来了，那我想使用全部变量怎么办呢？

4、常量

用变量可以灵活地保存数据、访问数据。不过有的时候，我们希望保存的数据不能更改，这种特殊的变量就被叫做“常量”。在C++中，有两种方式可以定义常量:

(1）使用符号常量这种方式是在文件头用#define来定义常量，也叫作“宏定义”。

define PI 3.14

跟#include一样，井号“#”开头的语句都是“预处理语句”，在编译之前，预处理器会查找程序中所有的“PI"，并把它替换成3.14。这种宏定义的方式是保留的c语言特性，在C++中一般不推荐。

(2）使用const限定符

这种方式跟定义一个变量是一样的,只需要在变量的数据类型前再加上一个const关键字，这被称为“限定符”。

//定义常量

const float Pi = 3.14; //不能修改常量值，只能初始化一次

const修饰的对象一旦创建就不能改变，所以必须初始化。

跟使用#define定义宏常量相比，const定义的常量有详细的数据类型，而且会在编译阶段进行安全检查，在运行时才完成替换，所以会更加安全和方便。

#include<iostream>
using namespace std;


int main()
{
	const float Pi = 3.14;  //常量
	cout << "Pi = " << Pi << endl;
	
}

输出结果：

5、数据类型

1.基本数据类型-整型

C++定义的基本整型包括char、 short、int、long，和C++11新增的long long类型，此外特殊的布尔类型bool本质上也是整型。

short类型至少为16位（2字节)int至少2字节，而且不能比 short短long至少4字节，而且不能比int短，long long至少8字节，而且不能比 long短。

现在一般系统中，short和 long 都选择最小长度，也就是short为16位、long为32位、long long 为64位;而int则有不同选择。我们一般使用的电脑操作系统，比如 Windows 7、Windows 10、Mac Os等等的实现中，int 都是32位的。

#include<iostream>
using namespace std;


int main()
{
	short a = 666;
	int b = 888;
	long c = 1;
	long long d = 2;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
	cout << "a的类型大小：" << sizeof a << endl;
	cout << "b的类型大小：" << sizeof b << endl;
	cout << "c的类型大小：" << sizeof c << endl;
	cout << "d的类型大小：" << sizeof d << endl;
}

运行结果：

2.char类型

最常用的字符编码集就是ASCII码，它用0~127表示了128个字符，这包括了所有的大小写字母、数字、标点符号、特殊符号以及一些计算机的控制符。比如字母“A”的编码是65,I数字字符“o”的编码是48。

在程序中如果使用char类型的变量,我们会发现,打印出来就是一个字符;而它的底层是一个整数，也可以做整数计算。

#include<iostream>
using namespace std;

int main()
{
	char a = 65;
	char b = a + 1;
	cout << "a = " << a << endl;
	cout << "a+1 = " << (a+1) << endl;
	cout << "b = " << b << endl;

	cin.get();
}

运行结果：

3.bool类型

在程序中，往往需要针对某个条件做判断，结果只有两种:“成立”和“不成立”;如果用逻辑语言来描述，就是“真”和“假”。真值判断是二元的，所以在c语言中，可以很简单地用“1”表示“真”，fo”表示“假”。

C++支持c语言中的这种定义，同时为了让代码更容易理解，引入了一种新的数据类型——布尔类型bool。bool类型只有两个取值: true和 false，这样就可以非常明确地表示逻辑真假了。bool类型通常占用8位（1个字节)。

#include<iostream>
using namespace std;

int main()
{
	bool b = true;
	cout << "b = " << b << endl;
	cout << "b占据长度为： " << sizeof b << endl;

	cin.get();
}

运行结果：

4.浮点类型

跟整数对应，浮点数用来表示小数，主要有单精度float和双精度double 两种类型，double的长度不会小于float。通常，float会占用4个字节(32位)，而double会占用8个字节(64位)。此外，C++还提供了一种扩展的高精度类型longdouble，一般会占12或16个字节。|

除了一般的小数，在C++中，还提供了另外一种浮点数的表示法，那就是科学计数法，也叫作“E表示法”。比如:5.98E24表示5.98×10的24次方;9.11e-31表示9.11×10的－31次方。

#include<iostream>
using namespace std;

int main()
{
	float a = 1.23;
	double b = 1.23e3;
	cout << "b = " << b << endl;
	cout << "a = " << a << endl;

	cin.get();
}

运行结果：

5.字面值常量

(1）整型字面值

整型字面值就是我们直接写的一个整数，比如 30。这是一个十进制数。而计算机底层是二进制的,所以还支持我们把一个数写成八进制和十六进制的形式。以0开头的整数表示八进制数;以0x或者0X开头的代表十六进制数。例如:

30十进制数

036八进制数

0x1E 十六进制数

这几个数本质上都是十进制的30，在计算机底层都是一样的。

在C++中，一个整型字面值，默认就是int类型，前提是数值在int能表示的范围内。如果超出int范围，那么就需要选择能够表示这个数的、长度最小的那个类型。

具体来说，对于十进制整型字面值，如果int不够那么选择long;还不够，就选择long long（不考虑无将号类型);而八进制和十六进制字面值，则会优先用无符号类型unsigned int,不够的话再选择long,之后依次是unsigned long、longlong和 unsigned long long。

这看起来非常复杂，很容易出现莫名其妙的错误。所以一般我们在定义整型字面值时，会给它加上一个后缀，明确地告诉计算机这个字面值是什么类型。

默认什么都不加，是int类型;

l或者L，表示long 类型;

II或者LL，表示long long类型;

u或者u，表示unsigned无符号类型;

我们一般会用大写L，避免跟数字1混淆;而u可以和i或LL组合使用。例如9527uLL就表示这个数是unsigned long long类型。

(2）浮点型字面值

前面已经提到，可以用一般的小数或者科学计数法表示的数，来给浮点类型赋值，这样的数就都是“浮点型字面值”。浮点型字面值默认的类型是double。如果我们希望明确指定类型，也可以加上相应的后缀:

f或者F，表示float类型

I或者L，表示long double类型

这里因为本身数值是小数或者科学计数法表示，所以工不会跟long 类型混淆。

(3）字符和字符串字面值

字符就是我们所说的字母、单个数字或者符号,字面值用单引号引起来表示。字符字面值默认的类型就是char，底层存储也是整型。

而多个字符组合在一起，就构成了“字符串”。字符串字面值是一串字符，用双引号引起来表示。

‘A’字符字面值， "Hello World!”字符串字面值

转义字符

有一类比较特殊的字符字面值，我们是不能直接使用的。在ASCll码中我们看到，除去字母、数字外还有很多符号，其中有一些本身在C++语法中有特殊的用途，比如单引号和双引号;另外还有一些控制字符。如果我们想要使用它们，就需要进行“转义”，这就是“转义字符”。

二、运算符

1、算数运算符

这里需要注意的是，同一个运算符，在不同的场合可能表达不同的含义。比如“一”，可以是“减号”也可以是“负号”:如果直接放在一个表达式前面，就是对表达式的结果取负数，这是一元运算符;如果连接两个表达式，就是两者结果相减，是二元运算符。

#include<iostream>
using namespace std;

int main()
{
	//算数运算符
	cout << "1 + 2 = " << 1 + 2 << endl;
	cout << "1 + 2 * 3 - 4 = " << 1 + 2 * 3 - 4 << endl;

	int a = 2, b = 4, c = 7;
	cout << "a + b = " << a + b << endl;
	cout << "a * b + c = " << a * b + c << endl;
	cout << "c / a = " << c / a << endl;    //两个整型数相除，结果还是整数

	float d = 10;
	cout << "d / b = " << d / b << endl;  //小数和整数相除，结果是小数
	cout << "c % b = " << c % b << endl;   //取模运算只能用于整数
	cout << "-c % b = " << -c % b << endl;

	cin.get();
}

运算结果：

2、赋值运算符

在C++中，用等号“=”表示一个赋值操作，这里的“=”就是赋值运算符。需要注意的是，赋值运算符的左边，必须是一个可修改的数据对象，比如假设我们已经定义了一个int类型的变量a，那么

a = 1; 这就是赋值。

赋值运算有以下一些规则:

赋值运算的结果，就是它左侧的运算对象;结果的类型就是左侧运算对象的类型;

如果赋值运算符两侧对象类型不同，就把右侧的对象转换成左侧对象的类型;

C++11新标准提供了一种新的语法:用花括号括起来的数值列表，可以作为赋值右侧对象。这样就可以非常方便地对一个数组赋值了;赋值运算满足右结合律。也就是说可以在一条语句中连续赋值，结合顺序是从右到左;

赋值运算符优先级较低，一般都会先执行其它运算符，最后做赋值;

3、复合赋值运算符

实际应用中，我们经常需要把一次计算的结果，再赋值给参与运算的某一个变量。最简单的例子就是多个数求和，比如我们要计算a、b、c的和，那么可以专门定义一个变量sum，用来保存求和结果:

常见的C++复合运算符包括：

+= ：a += b 表示将a和b相加，并将结果赋给a
-= ：a -= b 表示将a减去b，并将结果赋给a
*= ：a *= b 表示将a和b相乘，并将结果赋给a
/= ：a /= b 表示将a除以b，并将结果赋给a
%= ：a %= b 表示a对b取余，并将结果赋给a

4、关系和逻辑运算

1.关系运算符 -------结果是一个bool值

这里要注意区分的是，在C++语法中一个等号“=”表示的是赋值，两个等号“==”才是真正的“等于”。

关系运算符的相关规则:

算术运算符的优先级高于关系运算符，而如果加上括号就可以调整计算顺序;

关系运算符的返回值为布尔类型，如果参与算术计算，true的值为1，false的值为0;

#include<iostream>
using namespace std;

int main()
{
	//关系运算符
	int a = 1, b = 2, c = 3;
	cout << "a < b ：" << (a < b) << endl;
	cout << "c == a + b ：" << (c ==(a + b)) << endl;

	cin.get();
}

运算结果：

2.逻辑运算符

一个关系运算符的结果是一个布尔类型（ture或者false)，就可以表示一个条件的判断;如果需要多个条件的叠加，就可以用逻辑“与或非”将这些布尔类型组合起来。这样的运算符叫做“逻辑运算符”。

逻辑非（ !):一元运算符，将运算对象的值取反后返回，真值反转;

逻辑与（&&):二元运算符，两个运算对象都为 true时结果为true，否则结果为false;

逻辑或(|):二元运算符，两个运算对象只要有一个为 true 结果就为true，都为false则结果为false;

#include<iostream>
using namespace std;

int main()
{
	//逻辑运算符
	int a = 1, b = 2, c = 3;
	cout << "a < b && c > 5 ：" << (a < b && c > 5) << endl;
	cout << "a < b || c > 5 ：" << (a < b || c > 5) << endl;

	cin.get();
}

运行结果：

这里需要注意的规则有:

如果将一个算术类型的对象作为逻辑运算符的操作数，那么值为О表示false，非o值表示true;

逻辑与和逻辑或有两个运算对象，在计算时都是先求左侧对象的值，再求右侧对象的值;如果左侧对象的值已经能决定最终绪果，那么右侧就不会执行计算:这种策略叫做“短路求值”;

#include<iostream>
using namespace std;

int main()
{
	//短路求值
	int i = 0,j = 0;
	1 < 2 && ++i;
	cout << "i = " << i << endl;
	1 < 2 || ++j;
	cout << "j = " << j << endl;

	cin.get();
}

运行结果：

3.条件运算符

C++还从C语言继承了一个特殊的运算符，叫做“条件运算符”。它由“?”和“:”两个符号组成，需要三个运算表达式，形式如下:

条件判断表达式?表达式1∶表达式2

它的含义是:计算条件判断表达式的值，如果为true就执行表达式1，返回求值结果;如果为false 则跳过表达式1，执行表达式2，返回求值结果。这也是C++中唯一的一个三元运算符。

#include<iostream>
using namespace std;

int main()
{
	//条件运算符
	int i = 0;
	int a = 5, b = 2, max;
	cout << (1 < 2 && ++i ? "true" : "false") << endl;
	cout << "max = " << ((a > b) ? a : b) << endl;

	cin.get();
}

运行结果：

5、位运算符

之前介绍的所有运算符，主要都是针对算术类型的数据对象进行操作的;所有的算术类型，占用的空间都是以字节(byte，8位)作为单位来衡量的。在C++中，还有一类非常底层的运算符，可以直接操作到具体的每一位（bit）数据，这就是“位运算符”。

位运算符可以分为两大类:移位运算符，和位逻辑运算符。下面列出了所有位运算符的优先级和用法。

1.移位运算符

移位运算符有两种:左移运算符“<<”和右移运算符“>>”。

#include<iostream>
using namespace std;

int main()
{
	//位运算符
	unsigned char bits = 0xA8; //10101000
	cout << hex;
	cout << "bits右移2位：" << (bits >> 2) << endl; //0010 1010


	cin.get();
}

运行结果：

2.位逻辑运算符

计算机存储的每一个“位”(bit）都是二进制的，有0和1两种取值，这跟布尔类型的真值表达非常类似。于是自然可以想到，两个位上的“O”或“1”都可以执行类似逻辑运算的操作。

位逻辑运算符有:按位取反“~”，位与“&”，位或“|”和位异或“^”。

按位取反“~”:一元运算符，类似逻辑非。对每个位取反值，也就是把1置为0、0置为1;

位与“&”:二元运算符，类似逻辑与。两个数对应位上都为1，结果对应位为1;否则结果对应位为0;

位或“|”:二元运算符，类似逻辑或。两个数对应位上只要有1，结果对应位就为1;如果全为О则结果对应位为0;

位异或“^”:两个数对应位相同，则结果对应位为0;不同则结果对应位为0;

三、流程控制语句

1、条件分支

C++提供了两种按条件分支执行的控制语句:if 和switch。

1.if

if 语句主要就是判断一个条件是否为真(true),如果为真就执行下面的语句，如果为假则跳过。具体形式可以分为两种:一种是单独一个if，一般称为“单分支”;另一种是if ... else ...，称为“双分支”。

(1)单分支

单分支是最简单的if用法，判断的条件用小括号括起来跟在if后面，然后是如果条件为真要执行的语句。基本形式为:

#include<iostream>

using namespace std;

int main()
{
	//输入用户年龄，判断后显示欢迎信息
	cout << "请输入您的年龄：" << endl;
	int age;
	cin >> age;
	cin.get();
	if (age >= 18)
	{
		cout << "欢迎登录" << endl;
	}
	else
		cout << "少儿不宜" << endl;
	cin.get();
}

运行结果：

(2）嵌套分支（多分支)

程序中的分支有可能不只两个，这时就需要对if分支或者else分支再做条件判断和拆分了，这就是“嵌套分支”。

#include<iostream>

using namespace std;

int main()
{
	//输入用户年龄，判断后显示欢迎信息
	cout << "请输入您的年龄：" << endl;
	int age;
	cin >> age;
	cin.get();
	if (age >= 18)
	{
		cout << "欢迎登录" << endl;
		if(age < 35)
		{
			cout << "继续加油，年轻人" << endl;
		}
	}
	else
	{ 
		cout << "少儿不宜" << endl;
		if (age >= 12)
		{
			cout << "少年，好好学习" << endl;
		}
		else
			cout << "小朋友，别乱玩" << endl;
	}

	cin.get();
}

运行结果：

嵌套分支如果比较多，代码的可读性会大幅降低。所以还有一种更加简单的嵌套分支写法，那就是if ... else if ..，具体形式如下:

#include<iostream>

using namespace std;

int main()
{
	//输入用户年龄，判断后显示欢迎信息
	cout << "请输入您的年龄：" << endl;
	int age;
	cin >> age;
	cin.get();

	if(age < 12)
	{
		cout << "小朋友，别乱玩" << endl;
	}
	else if (age < 18)
	{
		cout << "少年，好好学习" << endl;
	}
	else if (age < 35)
	{
		cout << "好好玩" << endl;
	}
	else if (age < 60)
	{
		cout << "继续加油，中轻人" << endl;
	}
	else
	{
		cout << "好好休息" << endl;
	}

	cin.get();
}

运行结果:

2.switch

这里switch后面的括号里是一个表达式，对它求值，然后转换成整数类型跟下面每个case后面的值做比较;如果相等，就进入这个case指定的分支，执行后面的语句，直到swith 语句结束或者遇到break退出。需要注意的是:

case关键字和后面对应的值，合起来叫做一个“case标签”; case标签必须是一个整型的常量表达式;

任何两个case标签不能相同;

break语句的作用是“中断”，会直接跳转到switch语句结构的外面;

如果没有break 语句，那么匹配某个case标签之后，程序会从上到下一直执行下去;这会执行多个标签下面的语句，可能发生错误;

如果没有匹配上任何case标签的值，程序会执行default标签后面的语句; default是可选的，表示“默认要执行的操作”。

#include<iostream>

using namespace std;

int main()
{
	cout << "请输入您的成绩" << endl;
	char score;
	cin >> score;
	cin.get();

	switch (score)
	{
		case 'A':
			cout << "你真棒，获得优秀的成绩" << endl; break;
		case 'B':
			cout << "良好" << endl; break;
		case 'C':
			cout << "中等" << endl; break;
		case 'D':
			cout << "加油吧" << endl; break;
		default:
			break;
	}
	cin.get();
}

运行结果：

2、循环

C++中的循环语句，有while、do while和 for三种。

1.while

while只需要给定一个判断条件，只要条件为真，就重复地执行语句。形式如下:

要执行的语句往往会有多条，这就需要用花括号将它们括起来。这个块一般被称为“循环体”。

一般来说，用来控制while循环的条件中一定会包含变量，通常叫做“循环变量”;而它或者在条件中变化，或者在循环体中变化，这样才能保证循环能够终止退出。

#include<iostream>

using namespace std;

int main()
{
	cout << "循环即将开始...\n" << endl;
	int i = 1;
	while (i <= 10)
	{
		cout << "现在是第" << i << "循环" << endl;
		++i;
	}
	cin.get();
}

运行结果：

2.do while

do while和 while非常类似，区别在于do while是先执行循环体中的语句，然后再检查条件是否满足。所以do while至少会执行一次循环体。

do while语法形式如下:

#include<iostream>

using namespace std;

int main()
{
	cout << "循环即将开始...\n" << endl;
	int i = 1;
	while (i <= 10)
	{
		cout << "现在是第" << i << "循环" << endl;
		++i;
	}
	cout << "-------------------------" << endl;
	do
	{
		cout << "现在是倒数" << --i << "次循环" << endl;
	} while (i > 1);


	cin.get();
}

运行结果：

3.for

for循环的经典语法形式是:

关键字for和它后面括号里的部分，叫做“for语句头”。for语句头中有三部分，用分号分隔，主要作用是:

初始化语句负责初始化一个变量，这个变量值会随着循环迭代而改变，一般就是“循环变量”:

中间的条件是控制循环执行的关键，为真则执行下面的循环体语句，为假则退出。条件一般会以循环变量作为判断标准;

最后的表达式会在本次循环完成之后再执行，一般会对循环变量进行更改;

这三个部分并不是必要的，根据需要都可以进行省略。如果省略某个部分，需要保留分号表示这是一个空语句。

#include<iostream>

using namespace std;

int main()
{
	cout << "循环即将开始..." << endl;
	for (int i = 1; i <= 10; i++)
	{
		cout << "hello " << i << endl;
	}
	cout << "循环结束" << endl;

	cin.get();
}

运行结果：

九九乘法表例程：

#include<iostream>

using namespace std;

int main()
{
	//使用嵌套for循环实现九九乘法表
	//i:行号，j:列号
	for (int  i = 1; i <= 9; i++)
	{
		for (int j = 1; j <= i; j++)
		{
			cout << i << "*" << j << "=" << i * j << "\t";
		}
		cout << endl;
	}
	cin.get();
}

运行结果：

3、跳转

在流程控制语句中还有一类“跳转语句”，主要用来中断当前的执行过程。C++中有四种跳转语句: break，continue，goto 以及return 0；

1.break

#include<iostream>

using namespace std;

int main()
{
	int i = 1;
	while (true)
	{
		cout << "hello world,i = " << i++ << endl;
		if (i > 5)
		{
			break;
		}
	}
	cin.get();
}

运行结果：

2.continue

continue语句表示“继续”执行循环，也就是中断循环中的本次迭代、并开始执行下一次迭代。很明显，continue只能用在循环语句中，同样针对最近的一层循环有效。

#include<iostream>

using namespace std;

int main()
{
	//逢7过
	for (int num = 1; num <= 100; num++)
	{
		cout << "\t";
		//如果是7的倍数或者含7就跳过
		if (num % 7 == 0 || num % 10 == 7 || num / 10 == 7)
			continue;
		cout << num;

		//如果是10的倍数，则换行
		if (num % 10 == 0)
		{
			cout << endl << endl;
		}
	}
	cin.get();
}

运行结果：

3.goto

goto语句表示无条件地跳转到程序中的另一条语句。goto的语法形式为:

这里的“标签”可以认为是一条语句的“名字”，跟变量类似，只不过它是指代一条语句的标识符。定义标签也非常简单，只要在一条语句前写出标识符，然后跟上冒号就可以了，比如:

#include<iostream>

using namespace std;

int main()
{
	int i = 1;
p1:
	do
	{
		cout << "i = " << ++i << endl;
	} while (i < 10);

	if (i < 15)
	{
		goto p1;
	}

	cin.get();
}

运行结果：