语法基础课——第一讲 变量、输入输出、表达式和顺序语句

语法基础课——第一讲 变量、输入输出、表达式和顺序语句

AcWing的算法系列课程分为 4 4 4 个 l e v e l level level.

l e v e l    1 level ;1 level1：语法基础课，针对零基础的同学，主要介绍 C++ 在算法竞赛中的语法，视频课程时间为 25 25 25 小时.

不会涉及工程相关的语言

l e v e l    2 level ; 2 level2：算法基础课，主要介绍各种算法竞赛当中常用算法的原理、证明、代码模板，视频课程时间为 45 45 45 小时.

学完之后，应付找工作时的笔试、面试应该是没有问题的

l e v e l    3 level ; 3 level3：算法提高课，主要介绍各种常用算法的应用技巧，视频课程时间为 106 106 106 小时.

学完之后，拿取 NOIP 普及组和提高组的省一、ACM的银牌是没有任何问题的

l e v e l    4 level ; 4 level4：算法进阶课，讲一些特别难、复杂的题，视频课程时间为 86 86 86 小时.

对应到省选、NOI级别、ACM金牌水平

---

第一讲 变量、输入输出、表达式和顺序语句

---

编程是一种控制计算机的方式，和我们平时双击打开文件、关机、重启没有任何区别. ——闫学灿

学习一门编程语言，特别像打游戏，一定要多练才可以。和一些传统学科比起来，要提高动手能力.

能不能快速写完代码.（盲打是必须的要求）能不能快速找到代码的 bug.（这个能力特别重要，需要一定量的习题才能提升）

---

最简单的C++代码

---

先来看一个最简单的C++语言的代码：

// 代码 1-1
#include 
using namespace std;
int main()
{
    cout << "Hello World" << endl;
    return 0;
}

编译运行结果如下：

Hello World

C++语言的代码一般分为以下几个部分：

头文件

头文件的格式一般是#include+常用头文件的名字.

常用的头文件先不讲，只介绍这讲需要用到的两个头文件：

#include 
#include 

其中cstdio中含有两个函数：scanf和printf，分别是输入与输出.

另一个iostream中的cin和cout十分重要，也分别是输入与输出；当然，endl也在其中.

在代码编写中，这两个头文件的顺序是无所谓的，即

#include 
#include 

或者

#include 
#include 

这两种，头文件在代码开头给出的顺序，都是可以的.

可以将头文件理解为工具箱，函数理解为工具，编写代码理解为工作.

在工作时，我们需要将需要的工具带在身边，因为工具箱中就有现成的工具，所以我们需要先声明自己需要带上哪些工具箱，这样就可以随时快速地在里面翻找我们需要的工具.

声明：事先说明或者定义某个东西，在计算机领域称为“声明”.

命名空间 using namespace std;

其含义为：使用了std这个命名空间.

很多时候一个大的C++语言的项目，可能会有很多很多文件，不同文件之间的变量名可能会有冲突，namespace就是为了解决冲突而产生的一种语法；也就是说，只要在某个命名空间内没有冲突就可以了，不同的命名空间相互有冲突是没有关系的；平时使用的绝大部分库函数，包括cin、cout全部都是在std这个命名空间中的，因此这里需要加上使用命名空间的语句.

删掉这句话会报错，会提示cout等未被定义，因为没有加入命名空间.

命名空间可以理解为，某些工具箱为了不与其他工具箱发生混淆，事先是锁着的.

只有当我们需要用里面的工具时，我们可以用手头的钥匙把工具箱打开，这样就可以不发生混淆（虽然工具箱可能长得一样，但是锁和钥匙肯定是不配对的）；但我们现在所学的程序一般都比较简单，不怎么会发生混淆，所以提前声明使用这个命名空间，就相当于把原本该锁着的工具箱打开，让它一直处于开启状态，从而方便我们拿取工具.

当然，存在有些工具箱一开始就是没有锁，例如cstdio头文件中的scanf函数和printf函数就不存在于任何命名空间中，直接用就可以.

程序的执行入口，main函数

int main()
{

	return 0;
}

所有的C++语言的代码，都会优先去执行main函数中的语句.

语句：除了之后会介绍到的执行语句外，语句一般以分号（;）结尾.

这里的main只能叫main，不能修改，且main后面是一对小括号（()）.

在C++语言中，小括号（()）、中括号([]）、大括号（{}）的含义是完全不一样的，是不能混用的.

return 0; 一定要在最后，而且必须是返回0，否则会报错.

这里第 3 3 3 行的部分就可以用来补充其他东西.

综上，C++语言的程序的最基本框架为：

#include 
#include 
using namespace std;
int main()
{

	return 0;
}

当然，示例代码可以进行修改，将 Hello World 修改成其他东西输出都可以.

---

语法基础

---

变量

变量类似于中学学过的方程.

举个例子，比方说小明的年龄是 15 15 15 岁，小明的身高是 150 150 150 cm，那么根据这些信息可以写成：

age=15
height=150

age、height就可以称为变量.

变量是可以让程序记录信息，相当于把某些信息存下来的东西.

变量的类型

各种各样的信息有很多种，C++ 中一般把各种各样的信息分为如下几种：

bool 布尔类型

bool 存储两种值：真（true）或者假（false）.

bool 类型的 false，可以认为等于 0 0 0（也就是其和 0 0 0 作比较是相等的）.

bool 类型的 true，可以认为等于 1 1 1 .

char 字符类型

大家平时看到的d幕里的字母，都是一个一个的字符.

在 C++ 中，一个字符要用单引号引起来.

例如 'C'、'a'.

很多编程语言中，可能单引号('）双引号（"）是不作区分的，但是在C++语言中单引号和双引号是不同的，字符串才需要用双引号（"）引起来.

当然还有一些特殊字符，例如空格（' '）、回车（'n'）.（这里的 n 看起来是两个字符，但其实表达的只是回车这一个含义）

int 整数类型

C++语言的整数类型有一个表示的范围，即 − 2   147   483   648 ∼ 2   147   483   647 -2,147,483,648sim 2,147,483,647 −2147483648∼2147483647（ − 2 31 ∼ 2 31 − 1 -2^{31}sim 2^{31}-1 −231∼231−1，一共是 2 32 2^{32} 232 个数）

float 和 double 浮点数类型

在 C++ 中有两种浮点数类型.

其中一种为 float，可以表示例如 1.23 1.23 1.23、 2.5 2.5 2.5，也支持科学计数法 1.235 e 2 1.235e2 1.235e2.

例如 123.5 123.5 123.5 可以表示为 1.235 × 1 0 2 1.235 times 10^2 1.235×102，后者即为科学计数法.

而在C++语言中，科学计数法的表示为小数+e+ 10 10 10上的指数，例如上例子即为 1.235 e 2 1.235e2 1.235e2.

有效数字即为科学计数法中，小数部分能表示的数字的位数.

float 的精度是比较低的，也被称为单精度浮点数类型，有效数字的位数为 6 ∼ 7 6 sim 7 6∼7 位.

另一种为 double（其实是 double float 的简称），即为双精度浮点数类型，其有效数字的位数为 15 ∼ 16 15 sim 16 15∼16 位.

long long 长整数类型

long long（其实是 long long int 的简称），表示的是更长的整数类型，它的表示范围为 − 2 63 ∼ 2 63 − 1 -2^{63} sim 2^{63}-1 −263∼263−1（大约为 − 9 × 1 0 18 ∼ 9 × 1 0 18 -9times 10^{18} sim 9 times 10^{18} −9×1018∼9×1018）.

long double 浮点数类型

long double 的有效数字位数为 18 ∼ 19 18 sim 19 18∼19 位.

string 类型的内容将会放到第五讲去介绍.

字节

计算机中的文件都是有大小的，比如一个文件的大小为 18.6 18.6 18.6 KB.

其中的 B 表示的是 Byte（字节），还有一个 b 表示的是 bit（位），并且有 1 1 1 Byte = 8 8 8 bit.

这也就是为什么 8 8 8 Mb 带宽的下载速度平均只有 1 1 1 MB/s，因为这里指的是 8 8 8 兆（M）比特（bit），所以实际上 8 8 8 Mb = 1 1 1 MB.

显然，如果想要存储某些东西，必然要给它开辟一些空间，那么不同变量的大小是怎样的呢？

bool 布尔类型

在C++语言中，bool 类型是用类似 char 类型的方法实现的，一个 bool 类型的变量的大小为 1 1 1 Byte.

char 字符类型

一个 char 类型的变量的大小为 1 1 1 Byte.

由于 1 1 1 Byte 等于 8 8 8 bit，而 1 1 1 bit 可以表示 0 0 0 或者 1 1 1，所以 1 1 1 Byte 可以表示 8 8 8 位 0 0 0 或者 1 1 1（即一个 8 8 8 位数，每一位可以取 0 0 0 也可以取 1 1 1），因此 1 1 1 Byte 可以表示 2 8 = 256 2^{8}=256 28=256 个数.

int 整数类型

一个 int 类型的变量的大小为 4 4 4 Byte，所以 int 可以表示 2 32 2^{32} 232 个数.

float 和 double 浮点数类型

一个 float 类型的变量的大小为 4 4 4 Byte.

一个 double 类型的变量的大小为 8 8 8 Byte.

long long 长整数类型

一个 long long 类型的变量的大小为 8 8 8 Byte.

long double 浮点数类型

一个 long double 类型的变量的大小视编译器而决定，不同的编译器中 long double 的大小也有所区别，一般以 16 16 16 Byte 或 12 12 12 Byte 为主.

变量的类型总结 类型表示范围大小booltrue/false 1 1 1 Bytechar 0 ∼ 255 0 sim 255 0∼255 1 1 1 Byteint − 2 31 ∼ 2 31 − 1 -2^{31}sim 2^{31}-1 −231∼231−1 4 4 4 Bytefloat 6 ∼ 7 6 sim 7 6∼7 位有效数字 4 4 4 Bytedouble 15 ∼ 16 15 sim 16 15∼16 位有效数字 8 8 8 Bytelong long − 2 63 ∼ 2 63 − 1 -2^{63}sim 2^{63}-1 −263∼263−1 8 8 8 Bytelong double 18 ∼ 19 18 sim 19 18∼19 位有效数字 16 16 16 Byte 或 12 12 12 Byte 变量的定义

变量必须先定义，才可以使用，不能重名.

变量定义的方式：

// 代码 1-2
#include 
using namespace std;
int main()
{
    int a, b = 2, c = b;
    double d = 1.5, e = 1, f= 1.235e2;
    bool g = true, h = false;
    char j = 'a', k = 'b';
    
    long long l = 10000000000000000LL;
    long double m = 123.45;
    
    return 0;
}

先声明变量的类型是什么，隔一个空格后，是用逗号隔开的变量表达式，最后以一个分号结尾，即：

类型 ___,___,___,___;

其中变量表达式可以是一个变量，也可以是一个赋值表达式.

变量可以分开定义，也可以一起一次性定义（如代码 1-2的第 6 6 6 行），即可以使用逗号表达式隔开多个变量的定义，也可以每次只定义一个变量，也可以混用.

对于 int 类型的变量来说：

可以只是单纯声明一个变量（int a;）.

可以声明某个变量时赋予它初始值（int b = 2;，此时 b 的值为 2 2 2）.

可以将另一个同类型变量的值赋予给它（int c = b;，这时 c 的值是 b 所表示的数字，但并不意味着 c 与 b 绑定在了一起，仅仅是赋予了它这个数字而已）.

对于 float/double 类型的变量来说：

可以只是单纯声明一个变量.

可以声明某个变量时赋予它初始值（float d = 1.5;，此时 d 的值为 1.5 1.5 1.5）.

可以赋予它整数（整数也算特殊的浮点数，flota e = 1;，此时 e 的值为 1 1 1）.

可以使用科学计数法赋予它初始值（float f = 1.235e2;，此时 f 的值为 123.5 123.5 123.5）.

可以将另一个同类型变量的值赋予给它.

对于 bool 类型的变量来说：

可以只是单纯声明一个变量.

可以声明某个变量时赋予它初始值（bool g = true; bool h = false;）.

可以将另一个同类型变量的值赋予给它.

对于 char 类型的变量来说：

可以只是单纯声明一个变量.

可以声明某个变量时赋予它初始值（char j = 'a'）.

可以将另一个同类型变量的值赋予给它.

这里需要注意的是，在赋予初始值时，类似 int b = 2 中的 2 其实是一个整数类型，但如果这个整数特别大，需要使用 long long 类型去定义时，赋值的整数就应该为一个长整数类型了，就需要例如代码 1-2的第 11 11 11 行，在 10000000000000000 10000000000000000 10000000000000000 后加 LL 这一修饰词才能将其转化为长整数类型并赋值给长整型变量 l.

类似的，每个赋予的初值，都实际上对应了某种变量类型，例如 float d=1.5 中的 1.5 就默认为浮点数类型、char j='a' 中的 'a' 就是字符类型，所以需要注意赋初值时所赋予的初值是否符合变量范围.

变量名的命名必须满足如下三个规则：

只能适英文大小写字母、下划线（_）和阿拉伯数字（ 0 ∼ 9 0 sim 9 0∼9）；不能以阿拉伯数字开头；不能与C++语言中已有定义的关键字重名（如int在C++语言中就已经专门表示整数类型，它就不能用作变量名了）.

注意，两个变量即使数据类型不同，名称也不能相同.

输入输出 AcWing 1. A + B

原题链接

输入两个整数，求这两个整数的和是多少。

输入格式

输入两个整数 A , B A,B A,B，用空格隔开

输出格式

输出一个整数，表示这两个数的和

数据范围

0 ≤ A , B ≤ 1 0 8 0≤A,B≤10^8 0≤A,B≤108

样例输入：

3 4

样例输出：

7

时/空限制： 1s / 64MB
来源： AcWing
算法标签：模拟

---

为解决如上问题，有如下代码：

// 代码 1-3
#include 
using namespace std;
int main()
{
    int a, b; // 定义两个变量
    cin >> a >> b; // 输入
    cout << a + b << endl; // 输出
    return 0;
}
// 运行时间： 14 ms
// 运行空间： 216 KB

也就是说，代码需要我们输入两个变量 a , b a,b a,b，随后输出 a + b a+b a+b.

代码 1-3的第 6 6 6 行是定义变量.

代码 1-3的第 7 7 7 行是输入这两个变量.

其中双斜杠（//）表示的是注释行符，注释都是给人看的，机器会把当前行中，注释行符后面的内容都忽略掉.

还有表示注释块，在注释块的开头加上，则机器会把这中间的所有内容都忽略掉.

代码 1-3的第 8 8 8 行是输出 a + b a+b a+b 的值.

注意：

代码的第 6 , 7 , 8 6,7,8 6,7,8 行都是表达式，都算一条语句，每条语句都必须以分号（;）结束.cin和cout的符号方向问题. cin可以视为将值从cin中拿到 a a a 和 b b b 中去，可以想象成一个传送带的形式，故用的是>>；而cout是将 a + b a+b a+b 的值传输到cout中，故用的是<<.

如果想要输出多个变量呢？

//代码 1-4
#include 
using namespace std;
int main()
{
    int a, b; 
    cin >> a >> b; 
    cout << a + b << ' ' << a * b << endl; 
    return 0;
}

如上代码 1-4的第 8 8 8 行，即输出了 a + b a+b a+b 的值、一个空格、 a × b atimes b a×b 的值.

输入数据如下：

3 4

输出结果如下：

7 12

当然，输入输出也可以分开，例如上代码可以写成这样：

#include 
using namespace std;
int main()
{
   	int a, b; 
   	cin >> a;
   	cin >> b; 
   	cout << a + b;
   	cout << ' ' << a * b << endl; 
   	return 0;
}

scanf 和 printf

如何用scanf输入，用printf输出呢？

//代码 1-5
#include 
#include 
using namespace std;
int main()
{
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d %dn", a + b, a * b);
    return 0;
}

输入如代码 1-5的第 8 8 8 行所示，在scanf后是一个字符串，字符串中读入两个变量，这两个变量都是整数类型，其中%d是读入整数类型的意思，第几个%d对应着后面第几个变量，其中每个变量前都必须加一个取地址符号（&）.

输出如代码 1-5的第 9 9 9 行所示，在printf后是一个字符串，字符串对应着输出的样式，这里会输出两个整数（用空格隔开）并在行尾输出一个空格，其中第几个%d对应着后面第几个输出的变量.

如果想要使用格式化输出的话，代码如下：

#include 
#include 
using namespace std;
int main()
{
   	int a, b;
   	scanf("%d%d", &a, &b);
   	printf("a + b = %dna * b = %dn", a + b, a * b);
   	return 0;
}

输入数据如下：

3 4

输出结果如下：

a + b = 7
a * b = 12

这里就可以发现printf的优势，printf实际上是将字符串中的%d替换为相对应的变量的值.

cin和cout在输入输出时，不需要判断变量的类型是什么.

但是scanf和printf是需要判断变量的类型的.

如果想用scanf和printf输入输出浮点数类型变量，则需要在字符串中用%f替代.（默认保留 6 6 6 位小数）

如果想要保留 2 2 2 位小数时，则输出%.2f；即想要保留 x x x 位小数的话，输出格式即为%.xf.

#include 
#include 
using namespace std;
int main()
{
  	float a, b;
  	scanf("%f", &a);
  	scanf("%f", &b);
  	printf("a + b = %.1fna * b = %.2fn", a + b, a * b);
  	return 0;
}

输入数据如下：

3 4

输出结果如下：

a + b = 7.0
a * b = 12.00

cout保留几位小数输出的方法比较难写，这里不做介绍.

如果使用的是double类型的浮点数类型变量，则需要在字符串中用%lf代替.

---

如果想用scanf和printf输入输出字符类型变量，则需要在字符串中用%c替代.

注意，使用scanf读入时，%c是有可能读入空格的.

#include 
#include 
using namespace std;
int main()
{
 	char a, b;
  	scanf("%c%c", &a, &b);
  	printf("%c %cn", a, b);
  	return 0;
}

输入数据如下：

ac

输出结果如下：

a c

但是如果使用cin读入，则就不会读入空格.

#include 
#include 
using namespace std;
int main()
{
 	char a, b;
  	cin >> a >> b;
  	cout << a << ' ' << b << endl;
  	return 0;
}

输入数据如下：

a c

输出结果如下：

a c

---

如果想用scanf和printf输入输出长整数类型变量，则需要在字符串中用%lld替代.

总结

数据类型输入输出int%dfloat%fdouble%lfchar%clong long%lld

bool类型在输入输出时是被当成整数类型处理的.

在算法考试、算法笔试、算法面试当中，所有能用cin和cout的地方，一定可以替换成scanf和printf，但是能用scanf和printf的地方，不一定能替换成cin和cout.

因为cin和cout的运行效率比scanf和printf低很多，所以当输入数据比较多的时候，cin和cout就可能会超时，当然有一些优化方式，但是其优化完之后，在某些情况下和scanf和printf相比还是有一定的差距.

printf函数的格式化输出

如果想保证输出时宽度是一定的（因为数字的宽度可能是不同的，但若希望输出数字时能对齐输出的话），printf函数可以设置变量所占的宽度是多少，例如下代码：

#include 
#include 
using namespace std;
int main()
{
   	int a = 1;
   	int b = 23;
   	int c = 456;
   	double f = 12.45;
   	printf("%5d!n", a);
   	printf("%5d!n", b);
   	printf("%5d!n", c);
   	printf("%5.1lf!n", f);
   	return 0;
}

运行结果如下：

   1!
  23!
 456!
12.4!

其中%5d表示这个变量会占用 5 5 5 个宽度，若变量本身不足 5 5 5 个字符，就会在前面补上空格，变量本身超过 5 5 5 个字符，则会直接输出变量.

若想要在变量的右边补上空格，则需要写成%-xd，其中x为占用的宽度.

若想要在变量的左边补上 0 0 0，则需要写成%0xd，其中x为占用的宽度.

对于double类型的变量，同样支持所有如上的 *** 作，即输出形式可以是%x.yf，其中x为占用的宽度，y为保留的小数位数.

表达式 整数的加减乘除四则运算

//代码 1-6
#include 
#include 
using namespace std;
int main()
{
    int a = 6 + 3 * 4 / 2 -2;
    cout << a << endl;
    int b = a * 10 + 5 / 2;
    cout << b << endl;
    cout << 23 * 56 - 78 / 3 << endl;
    return 0;
}

运行结果如下：

10
102
1262

若 A=10，B=20

运算符描述实例+把两个 *** 作数相加A + B 将得到 30-从第一个 *** 作数中减去第二个 *** 作数A - B 将得到 -10*把两个 *** 作数相乘A * B 将得到 200/分子除以分母B / A 将得到 2%取模运算符，整除后的余数B % A 将得到 0

对于整数来说，除法是整除：

#include 
using namespace std;
int main()
{
	cout << 5 / 2 << endl;
	return 0;
}

输出结果如下：

2

但对于浮点数来说，除的结果仍是浮点数：

#include 
using namespace std;
int main()
{
	cout << 5.0 / 2.0 << endl;
	return 0;
}

输出结果如下：

2.5

浮点数是没有取模运算（%）的.

值得注意的是，C++语言中的取模与数学上的取模是不一样的，数学中余数的定义是必须要大于等于 0 0 0，严格小于除数，而在C++语言中，如果被除数是负的，则余数就是负的，而除数对余数符号是没有影响的.

#include 
using namespace std;
int main()
{
	cout << 5 % 2 << endl;
	cout << -5 % 2 << endl;
	return 0;
}

运行结果如下：

1
-1

C++语言的整除规则不是等同于 x ÷ y = ⌊ x y ⌋ xdiv y=lfloorfrac{x}{y}rfloor x÷y=⌊yx​⌋ （向下取整）的，而是直接抹掉小数部分后得到的结果，可以理解为向 0 0 0 取整.

而python语言的整除规则是等同于 x ÷ y = ⌊ x y ⌋ x div y=lfloorfrac{x}{y}rfloor x÷y=⌊yx​⌋，所以两种计算机语言的整除和取模的运算结果是有区别的.

因为两者的取模运算逻辑都等同于 x % y = x − ( x ÷ y ) × y x % y=x-(xdiv y) times y x%y=x−(x÷y)×y，但由于整除的实现方法不同，导致取模后的结果不同，这点在 x x x 是负数时表现最为明显.

例，如下为C++语言代码：

#include 
using namespace std;
int main()
{
	int x = -5, y = 2;
	cout << x / y << endl;
   	cout << x % y << endl;
	return 0;
}

运行结果如下：

-2
-1

如下为python语言代码：

x = -5
y = 2
print (x // y)
print (x % y)

运行结果如下：

-3
1

浮点数（小数）的运算

//代码 1-7
#include 
#include 
using namespace std;
int main()
{
    float x = 1.5, y = 3.2;
    cout << x * y << ' ' << x + y << endl;
    cout << x - y << ' ' << x / y << endl;
    return 0;
}

运行结果如下：

4.8 4.7
-1.7 0.46875

整型变量的自增、自减

//代码 1-8
#include 
#include 
using namespace std;
int main()
{
    int a = 6;
    a ++ ;
    cout << a << endl;
    int b = 6;
    ++ b;
    cout << b << endl;
    return 0;
}

如上代码 1-8，其中第 8 8 8 行 a ++;和第 11 11 11 行 ++ b; 即为整型变量的自增运算，对于变量本身来说，这两种运算是完全一样的.

运行结果如下：

7
7

但是，实际上这两种运算是有区别的：

//代码 1-9
#include 
#include 
using namespace std;
int main()
{
    int a = 6;
    int c = a ++ ;
    cout << a << ' ' << c << endl;
    int b = 6;
    int d = ++ b;
    cout << b << ' ' << d << endl;
    return 0;
}

运行结果如下：

7 6
7 7

如代码 1-9的第 8 8 8 行，a ++的意思是，先将a的值赋给c，然后再把a + 1.

如代码 1-9的第 11 11 11 行，++ b的意思是，先将b + 1，然后把b的值赋给d.

当然，自减运算也是同理.

#include 
#include 
using namespace std;
int main()
{
   	int a = 6;
   	int c = a -- ;
   	cout << a << ' ' << c << endl;
   	int b = 6;
   	int d = -- b;
   	cout << b << ' ' << d << endl;
   	return 0;
}

运行结果如下：

5 6
5 5

自增和自减运算只有整数有.

简写运算

//代码 1-10
#include 
#include 
using namespace std;
int main()
{
   	int a = 6;
   	int b = 7;
   	b += a; b = b + a;
   	b -= a; b = b - a;
   	b *= a; b = b * a;
   	b /= a; b = b / a;
   	b %= a; b = b % a; 
   	return 0;
}

在如上代码 1-10中的第 9 ∼ 13 9 sim 13 9∼13 中，后一条语句均可以用前一条语句代替.

变量的类型转换

不同的变量类型之间是可以相互赋值的.

int 转化为 float/double

整数转换为浮点数是直接转换过去的.

float/double 转化为 int

浮点数转化为整数，会向下取整.

#include 
#include 
using namespace std;
int main()
{
    float a = 5.23;
    int b = (int)a;
    printf("%d", b);
    return 0;
}

运行结果如下：

5

int 转化为 char / char 转化为 int

整数类型和字符类型通过ASCⅡ码表相对应.

例如'a'对应 97 97 97、'A'对应 65 65 65、'0'对应 48 48 48、' '（空格）对应 32 32 32.

常用的ASCⅡ码表对应数字范围为 0 ∼ 127 0 sim 127 0∼127.

#include 
#include 
using namespace std;
int main()
{
    int t = 97;
    char c = (char)t;
    cout << c << endl;
    return 0;
}

运行结果如下：

a

既然char能跟int进行转换，那么char其实也是支持运算的.

//代码 1-11
#include 
#include 
using namespace std;
int main()
{
   	char c = 'A';
   	cout << (char)(c + 32) << endl;
   	return 0;
}

运行结果如下：

a

因为char和整数进行加减运算，结果会变为一个整数，所以在代码 1-11的第 8 8 8 行对运算结果也进行了类型转换.

如上都是一些显式强制类型转换，但是还有一些隐式强制类型转换.

#include 
#include 
using namespace std;
int main()
{
   	int a = 6;
   	float b = 1.3;
   	cout << a * b << endl;
   	return 0;
}

运行结果如下：

7.8

也就是说：

int和float或者double作运算的话，结果会是浮点数类型.

char和int作运算的话，结果会是整数类型.

int和long long作运算的话，结果会是长整数类型.

float和double作运算的话，结果会是double类型.

如果参与运算的两个类型不一样的话，C++会默认将精度较低的类型转化为精度比较高的类型.

顺序语句

顺序语句，实际上就是C++在执行代码时，会从上往下，顺序地执行.

这样的执行顺序叫做顺序语句.

//代码 1-12
#include 
#include 
using namespace std;
int main()
{
    int a;
    cin >> a;
    int b = a + 2;
    int c = b * 3, d;
    d = c * 2;
    cout << d << endl;
    return 0;
}

如上代码 1-12：

进入main函数后，先执行第 7 7 7 行语句，定义变量a.执行第 8 8 8 行语句，输出变量a的值，假定为 2 2 2.执行第 9 9 9 行语句，定义变量b，并将其初值赋成a+2，即 4 4 4.执行第 10 10 10 行语句，定义变量c和d，并将c的初值赋成b*3，即 12 12 12.执行第 11 11 11 行语句，将变量d的值赋成c*2，即 24 24 24.执行第 12 12 12 行语句，输出变量d的值.执行第 13 13 13 行语句，return 0代表了程序结束.

今后会有其他的代码执行顺序.

---

习题

---

输出第二个整数

读入三个整数，并输出第二个整数.

#include 
#include 
using namespace std;
int main()
{
    int a, b, c;
    cin >> a >> b >> c;
    cout << b << endl;
    return 0;
}

计算 (a + b) * c 的值

读入三个整数 a , b , c a,b,c a,b,c，输出 ( a + b ) ∗ c (a+b)*c (a+b)∗c.

#include 
#include 
using namespace std;
int main()
{
    int a, b, c;
    cin >> a >> b >> c;
    cout << (a + b) * c << endl;
    return 0;
}

带余除法

读入两个整数 a , b a,b a,b，输出 a ÷ b a div b a÷b 的商和余数.

#include 
#include 
using namespace std;
int main()
{
    int a, b;
    cin >> a >> b;
    int c = a / b, d = a % b;
    cout << c << ' ' << d << endl;
    return 0;
}

求反三位数

读入一个三位整数，将其翻转后输出.

#include 
#include 
using namespace std;
int main()
{
    int n;
    cin >> n;
    int a = n % 10;
    n = n / 10;
    int b = n % 10;
    n = n / 10;
    int c= n;
    cout << a << b << c << endl;
    return 0;
}

交换两个整数

读入两个整数，并将它们交换后输出.

#include 
#include 
using namespace std;
int main()
{
    int a, b;
    cin >> a >> b;
    int t = a;
    a = b;
    b = t;
    cout << a << ' ' << b << endl;
    return 0;
}

输出菱形

试读入一个字符，观察输出的图形.

#include 
#include 
using namespace std;
int main()
{
    char c;
    cin >> c;
    cout << "  " << c << endl;
    cout << " " << c << c << c << endl;
    cout << c << c << c << c << c << endl;
    cout << " " << c << c << c << endl;
    cout << "  " << c << endl;
    return 0;
}

---

本文档基于 AcWing语法基础课 制作

视频链接：1.1 变量、输入输出、表达式和顺序语句 - AcWing

文档版本：

var1.0 完成于2022.01.29.