# 课堂笔记

# 数据类型

不同的表示形式
不同的存储空间
不同的运算

# 整数 int

表示的数较小，就用短整型
表示的数较大，就用整型或长整型
表示的数均是非负数，就用无符号型

方括号表示可选，如 unsigned [int]，表示使用 unsigned int 也可以，使用 unsigned 也可以

• 整型数：一个数不带小数点，可以带正负号。如： 1 , 12 , +123 , -1234
• 十六进制整数：前缀 0x (x 大小写均可)。如： 0xFF , 0x10 , 0x21 , -0XFF , -0X10 , -0X21
• 八进制整数：前缀 0 。如： 010 , 021 , -010 , -021
• 十进制、十六进制、八进制，没小数点，都是整型，都占 4 个字节。
  如： 16 ， 0x10 , 020 在计算机中存的都是 16 这个数。

cout<<16<<" "<<0x10<<" "<<020<<endl;

// 输出 16 16 16

• 无符号整型数：加后缀 U 或 u 。如： 1U , 12U , 123U , 2014u
  无符号，就意味着可以写绝对值更大的数。

# 实数 float double

C++ 采用 IEEE754 标准，有两种格式：

• 双精度数：数据带小数点

  • 小数形式： 1.0 , 1. , 0.1 , .1

    1 是整数型，占 4 个字节； 1. 是双精度浮点型，占 8 个字节
    1/2 和 1.0/2 的运算结果不一样

  • 指数形式： 1.2E-2 表示 1.2×10^-2， 1.2e+2 表示 1.2×10²， -1.2E2 表示 - 1.2×10²

• 单精度数：带小数点，加后缀 F 或 f ，如 12.5F ， 1.25E-2F ， -12.5f

# 字符 char

字符型 char 是单个字符的表示。

• 方法：
  将字母写在一对单引号中表示字符，如： 'A' , 'B' , 'C' ， 'a' , 'b' , 'c' ， '0' , '1' , '2' , '3' ， '#' , '$' , '%'

• 字节数：
  每个字符占一个字节，保存英文字符的 ASCII 码值。

  实际也是一个整数，可以参与整型数能进行的运算，如 'a'+1 。

• 注意：

  • 'a' 和 a 是不一样的： 'a' 是字符，表示 a 本身， a 标识符，如变量，代表别的数据
  • '0' 和 0 是有本质区别的：
    '0' ，是字符，1 字节，存 ASCII 码 48 ，二进制 0011 0000
0 ，是整数，4 字节，存的是 0 ，二进制 0000...0 （32 个 0）

# 转义字符

用一个反斜杠 + 一个字母 (或数字) 表示，它也是 1 个字符。

• 有些 ASCII 符号是不可显示的，如换行符、回车符、退格符、水平制表符等。
• 有些是有的特殊意义的，比如单引号、双引号、反斜杠等。

cout<<'\''; // 显示单引号

cout<<'\"'; // 显示双引号

// 将 "Hello World" 显示到两行上

// 方法 1

cout<<"Hello"<<endl;

cout<<"World"<<endl;

// 方法 2

cout<<"Hello"<<endl<<"World"<<endl;

// 方法 3

cout<<"Hello \nWorld";

/*

显示

1234 12  567

12   143 12

按列对齐

*/

// 方法 1，加入空格，需要自己数空格

cout<<1234<<" "<<12<<" "<<567<<endl;

cout<<12<<"  "<<143<<" "<<12<<endl;

// 方法 2，加入 \t，相当于每个间隔 8 位

cout<<1234<<"\t"<<12<<"\t"<<567<<endl;

cout<<12<<"\t"<<143<<"\t"<<12<<endl;

cout<<"1-abcde\n#12345"<<endl;

/* 显示内容：

1-abcde

#12345

*/

cout<<"2-abcde\r#12345"<<endl;

/* 显示内容：

#12345

备注：显示到 \r 时回车到本行第一个字符，后续内容覆盖显示

*/

cout<<"3-abcde\t#12345"<<endl;

/* 显示内容：

3-abcde	#12345

*/

cout<<"4-abcde\f#12345"<<endl;

/* 屏幕显示内容：

4-abcde#12345

备注：打印机上到 \f 则会换页

*/

cout<<"5-abcde\b#12345"<<endl;

/* 显示内容：

5-abcd#12345

备注：显示到 \b 时退格到 e，接着覆盖显示后续内容

*/

cout<<"9-abcde\0#12345"<<endl;

/* 显示内容：

10-abcde

备注：显示到 \0 时，表示字符串已经结束，后续内容不再显示

*/

cout<<"10-abcde\141#12345"<<endl;

/* 显示内容：

10-abcdea#123456

备注：显示到 \141 表示一个八进制数，转换为十进制为 97，显示的是 a

*/

# 字符串

是连续的多个字符

• 方法：
  字符串写在一对双引号之间，如 "Hello World" "程序设计"
• 字节数：
  • 字符串占的字节数等于 字符串长度+1

为什么 + 1？

• 末尾加了一个结束符，用空字符 '\0' ^{ASCII 码第一个字符}表示，数值上是 0。
• 空字符 '\0' ，什么也没有，ASCII 码值为 0；
  空格 ' ' ，占一个字符位，不显示图案，ASCII 码值为 32，两者不同。

• "Hello World" ，长度 11 (10 个字母 + 1 个空格)，占 12 字节
• "程序设计" ，长度 8 (4 个汉字 8 字节)，占 9 个字节

# 逻辑型（布尔型）bool

表示 “真”，“假” 这样判断的结果

• 取值：
  true，表示 "真"
  false，表示" 假 "
• 存储：
  true，存的是 1
  false，存的是 0
• 非 0 数值，当逻辑值相当于 true
• 数值 0，当逻辑值相当于 fasle
• 逻辑型数存放的实际也是整数，可以进行数学运算

# 计算字节数 sizeof ()

• C++ 没有规定不同类型的数占的字节数
• 字节数会因计算机系统、编译器的不同而不同
• 用 sizeof() 运算符测试某类型数所占字节数

sizeof(<类型名>) // 类型占字节数

cout<<sizeof(int)<<endl;// 整型数的字节数

cout<<sizeof(short int)<<endl;

cout<<sizeof(short)<<endl; ;// 短整型的字节数

sizeof(<数据>)// 数据的字节数

cout<<sizeof(5)<<endl;

cout<<sizeof(5.0)<<endl;

cout<<sizeof('A')<<endl;

cout<<sizeof(true)<<endl;

cout<<sizeof("Hello World")<<endl;

cout<<sizeof("程序设计")<<endl;

sizeof 用法很像函数，但 C++ 却称它是运算符。
sizeof (常量、变量、表达式) 都可。

# 数据表示方法

常量指不能改变的量，变量指值可以变的量。

# 字面常量

字面量、直接常量：直接写出的数据。

2,3,4;

1.2,1.3;

"Hello world!","C++";

cout<<2015;

# 符号常量 const #define

用符号表示数据，一旦确定了表示哪个数据，以后就不能再改变。

• 说明方法一 const

const <类型说明符> <符号常量名> =<数据>;

const int N=100;

const double pai=3.1415926;

const char A='E';

const char CPP[20]="C++ Programming";

const int M=100, K=100;

// 以下为错误的说明语句

N=200;

pai=3.14;

A='F';

行末有分号，是语句

• 说明方法二 #define

// 在 main 函数前

#define <符号名称> <数据>

#define PAI 3.14

注意：行末没有分号，这不是 C++ 语句，称为预处理。
程序编译时，先将 <符号名称> 全部替换为 < 数据 >，然后才正式编译，所以这样的说明称为编译预处理。

# 变量

变量是用符号表示数据，它表示的数据是可以变的。

• 变量的说明
  也叫变量的声明，意味着编译系统会给这个变量在内存中分配一个存储单元。所以变量的声明也叫变量的定义。

<类型说明符> <变量名表> ;

int a;

double d1,d2;

char c1,c2,c3;

• 变量的初始化
  在声明变量的同时说明它代表的数据是什么。

<类型说明符> <变量名1>=<值或表达式1>[, <变量名2>=<值或表达式2>];

int a=5;

double pai=3.14, e=2.71828;

char A='?', B='%';

cout<<2*pai*a<<endl;

• 变量的赋值
  等号 = 称为赋值运算符，其作用之一是将右边表达式的值，放到左边变量的存储单元中去。
  表达式：用运算符连接起来的式子，单个变量、常量也是表达式。

<变量名>=<值或表达式>;

const double PAI=3.14; // 声明常量 PAI

double r, area; // 声明变量 r，area 分别表示半径和面积

r=5.0; // 为 r 赋值

cin>>r; // 通过输入为 r 赋值

area=PAI*r*r; // 计算圆的面积并赋值给 area

cout<<area<<endl; // 显示结果

• 使用注意点

1. 先定义，再使用
2. 只能定义一次，不能重复定义
3. 先赋值，再参与计算
4. 变量可以多次赋值，而常量是不能赋值的
5. 变量的定义可以出现在使用前的任何地方，但建议在程序的开始定义变量
6. 少用或不用字面常量

# 算术运算

# 算术运算符

• 表示运算的符号称为运算符。

  • 算数运算
  • 比较运算
  • 逻辑运算
  • 位运算

• 算术运算包括加 + 、减 - 、乘 * 、除 / 、求余数 % 、乘方、指数、对数、三角函数等。

• 运算符作用的对象称为操作数， % 运算的两个操作数，必须都是整数

注意：

1. 乘法运算符不能省略，数学中写 $b^2-4ac$，程序中应写为 b*b-4.0*a*c
2. 除数是表达式时，注意加括号，例如 $\frac{x}{2a}$，应写为 x/2.0/a 或 x/(2.0*a) ，不能写成 x/2*a 或 x/2a

# 数学函数 #include<cmath>

• C++ 中没有乘方运算符，也没有指数、对数、三角函数的运算符，它们是通过函数的调用实现的。如

  pow(x,n) $x^n$
  exp(x) $e^x$
  log(x) x 的自然对数的对数
  log10(x) x 的常用对数
  sin(x) x 的正弦（弧度）
  cos(x) x 的余弦（弧度）
  tan(x) x 的正切（弧度）
  1/tan(x) 余切
  asin(x) 反正弦函数 $x∈[-1,1]$

#include<iostream>

#include<cmath> // 数学函数包含在头文件 cmath 中

using namespace std;

int main()

{

	double x;

	cin>>x;

	cout<<"sin(x)="<<sin(x)<<endl;

	cout<<"cos(x)="<<cos(x)<<endl;

	cout<<"tan(x)="<<tan(x)<<endl;

	return 0;

}

对指数运算，$x^n$，如果 n 是 2,3,4 较小的整数时，一般使用连乘更简单
x*x x*x*x x*x*x*x ，避免使用 pow(x,n)

# 自增自减运算符

• 前置 ++ ： ++i ，前置 -- ： --i

• 后置 ++ ： i++ ，后置 -- ： i--

• 双目运算（二元运算）：运算符需要两个操作数

• 单目运算（一元运算）：运算符需要一个操作数

# 作用

1. 无论前置、后置， ++ 使变量自身加 1， -- 使变量自身减 1。

int n=5,m=10;

n++; // 相当于 n=n+1;

m--; // 相当于 m=m-1

cout<<n<<endl; // 结果 6

cout<<m<<endl; // 结果 9

2. 作为表达式时，前置运算符的结果是加 1 或减 1 之后的结果；后置运算符的结果是加 1 或减 1 之前的结果。

int n=5,m=10;

int a,b,c,d; // 声明整型变量

a=n++; 

b=m--;

cout<<a<<"\t"<<b<<"\t"<<n<<'\t'<<m<<endl;

// 5	10	6	9

n=5,m=10;

a=++n;

b=--m;

cout<<a<<"\t"<<b<<"\t"<<n<<'\t'<<m<<endl;

// 6	9	6	9

# 建议

1. 使用单独的表达式语句

int n=20;

i++;

i--;

++i;

--i;

2. 尽量不将其放入表达式中

int a,n=10;

a=i++ + i++; // 不推荐

cout<<i++<<'\t'<<i++<<'\t'<<i++<<endl; // 绝对不用

# 优先级

• 先乘除求余，后加减，级别相同的从左向右逐个计算
  1+2*3 2+3+4 6*2/3

• 圆括号可以改变优先级
  (1+2)*3

• 圆括号可以嵌套，越靠里，圆括号的优先级越高。
  ((1+2)*3+(2+3)*2)*7

• % 和 * / 优先级别相同

• 后置 ++ -- 的优先级 > 前置 ++ -- 的优先级

• 前置 ++ -- 的优先级 > 乘除的优先级

建议使用圆括号，标明计算的优先顺序

# 运算的数据类型

• 相同类型的数据进行算术运算，结果还是这种数据类型。
  1+2 1-2 1*2 1/2
1.0+2.0 1.0-2.0 1.0*2.0 1.0/2.0

• 不同类型的数据运算，默认向级别高的类型转换。
  (低) short , char ➡️ int ➡️ unsigned ➡️ long ➡️ double (高)
  1/2.0 1.0/2

整数和整数运算结果是整数：
所以 1/2 结果为 0
1.0/2 或 1/2.0 结果为 0.5

• 强制类型转换

(<类型>)x 或 <类型>(x)

// 将 x 转换为 < 类型 > 的数据

//x 可以是表达式

(double)a/b

int(3.0/2.0)

double(1/2) 

int a=7,b=3;

double c;

// 若想得到 a 除 b 的实数结果，则

c=(double)a/b;

# 复合运算符

+= -= *= /= %=

# 关系运算

比较运算：
对数的 “大小” 关系的判断

# 关系运算符

# 关系表达式

将两个表达式用关系运算符连接起来，构成关系表达式。

<表达式1> <关系运算符> <表达式2>

其中的表达式可以是算术表达式、关系表达式、逻辑表达式、赋值表达式、字符表达式等

目前表达式的值类型应为整数类型或实数类型，如： int , float , double , char 或 bool

每个表达式都有一个确定的值，它们有 “序” 关系

double a=1.0,b=-4.0,c=3.0;

b*b-4.0*a*c == 0

b*b-4.0*a*c > 0

一个常量，一个变量也是表达式。

# 运算结果

关系表达式的运算结果为逻辑值， true false

逻辑值 true ，计算机中存的是 1
逻辑值 false , 计算机中存的是 0

cout<<true<<" "<<false<<endl;

// 结果：1 0

# 优先级

• 从高到低：

  • 算术运算
  • 关系运算 > < >= <=
  • 关系运算 == !=
  • 赋值运算、复合算术运算

• 关系运算符的结合顺序：从左向右

# 注意事项

• 在判断两个表达式的值是否相等的时候，一定用两个等号，不能用一个等号

#include<iostream>

using namespace std;

int main()

{

	int a,b;

	bool f;

	cin>>a>>b;

	cout<<(a==b)<<endl;

	f=(a==b);

	cout<<f<<endl;

	return 0;

}

• 关系运算符不要连用
  5<x<10 表达式正确，但值永远是 1

# 逻辑运算

表达、判断多个条件之间的关系，同时成立、之一成立、不成立。

# 逻辑运算符

# 逻辑表达式

逻辑运算符和关系表达式或有数值的表达式连接，构成逻辑表达式。

• 双目运算

<条件1> && <条件2>

<条件1> || <条件2>

• 单目运算

!<条件>

double x;

cin>>x;

x>=0 && x<=1 // x∈[0,1]

x<0 || x>1 // x ∉ [0,1]

!(x>=0 && x<=1) // x ∉ [0,1]

!(x<0) //x 非负，x>=0

# 表达式的值

逻辑值： true ， false

• 与运算 <条件1> && <条件2> 两个都为 true ➡️ true

• 或运算 <条件1>||<条件2> 只要一个为 true ➡️ true

• 非运算 !<条件>

# 优先级

• 从高到低：
  • 逻辑非 ! ，负号 -
  • 乘、除、求余 * / %
  • 加、减 + -
  • 大于小于 > , >= , < , <=
  • 等于不等于 == , !=
  • 逻辑与 &&
  • 逻辑或 ||

! 高于 算术运算 高于 关系运算 高于 && 高于 ||

• 结合顺序：
  • && , || 从左到右
  • ！ 从右向左

# 注意事项

• 单个变量或常量也可作为条件
• 逻辑表达式的短路求值 (short circuit evaluation)：如果判断了前面的条件，已经能得到表达式的结果，就不再计算后面的条件。

# 位运算

• 数据在计算机中是以二进制数的形式存放的。
• 位运算：对整数的二进制位进行的操作

a=0110 1001B
b=0101 1110B

• 位运算只能对整数进行。

• 包括：与 (and)、或 (or)、取反 (not)、异或 (xor)、左移、右移

  • 按位 “与”、按位 “或”、按位 “异或” 为双目运算
  • 按位 “取反” 为单目运算

# 位运算符

<整数类型表达式1> <位运算符> <整数类型表达式2>

~<整数类型表达式>

# 运算结果

• 按位 “与”
  全为 1 才为 1

• 按位 “或”
  只要有一个为 1 即为 1

• 按位 “异或”
  两个操作数不同则为 1
  两个操作数相同则为 0

• 按位 “取反”

• 移位运算
  将二进制数的每一位 向左 或 向右 移动 指定的数位

如：左移两位

# 优先级

~ > 算术运算 > 比较运算 > & > ^ > |

• 从高到低

# 应用

• 按位 “与” 可以将某些位设置为 0

• 按位 “或” 可以将某些位设置为 1

• 按位 “异或” 可以让某些位变反，而另一些位不变
  • 和 1"异或" 变反
    1^1 ➡️ 0
    0^1 ➡️ 1
  • 和 0"异或" 不变
    1^0 ➡️ 1
    0^0 ➡️ 0

# 复合位运算

• 优先级：很低，与复合算术运算、等号同级
• 结合顺序：从右向左

# 注意事项

• 一个 & 和两个 && 是不同的
• 在输出中使用移位运算的表达式时，要加括号

cout<<4<<2<<endl; // 结果 42

cout<<(4<<2)<<endl; // 结果 16

// 重载

# 特殊运算符

# 赋值运算符

等号 "=" 是赋值运算符

<变量> = <表达式>

# 作用

1. 将右边表达式的值存入左边的变量中

int a=3,b=5,c;

c=a+b; // 赋值语句

2. 作为表达式，它的值就是右边 <表达式> 的值

int a=3,b=5,c;

cout<<(c=a+b)<<endl; // 显示 8

cout<<c<<endl; // 显示 8

# 优先级

• 优先级较低，低于逻辑运算，和复合算术运算和复
  合位运算是同级的
• 结合顺序是从右向左。

int a=1,b=5,x,y,z;

x= y= z = a+b ;

// x=( y= ( z = a+b ) ) ;

z=x+y=a+b;

// [Error] lvalue required as left operand of assignment

# 左值和右值

• 左值 lvalue

  • 能够出现在等号左边的式子
  • 能够被赋值的量
  • 变量、数组元素、对象等

• 右值 rvalue

  • 有值的表达式

z=x+y=a+b; // 不正确

z=x+(y=a+b); // 正确

cout<<(c=a+b)<<endl;// 不推荐

x= y=z=a+b ; // 不推荐

z=x+(y=a+b); // 不推荐

# 字节数运算符

求某类型的数据或表达式的值占的字节数

sizeof(<常量、变量、数组、对象>) // 表达式的特例、

sizeof(<类型>) // 用法象函数，叫运算符

sizeof(<表达式>)

cout<<sizeof(int)<<" "<<sizeof(x>1)<<endl;

# 条件运算符

条件运算符、问号运算符？：
三目运算

<条件> ? <表达式1> : <表达式2>

<表达式 1> 和 < 表达式 2> 的值应具有相同的类型，或能转换为相同的类型

y= ( t >= 0 ? 1 : 0 ); // 正确

y=( x > 1 ? 1 : "error" ); // 错误

# 逗号运算符

逗号 "," 是一个运算符
多个表达式用逗号隔开，构成逗号表达式。

<表达式1> , <表达式2> , ... , <表达式n>

从左向右依次计算 n 个表达式的值
整个表达式的值为 <表达式 n> 的值

int a=1,b=2,c=3;

int y;

y=(a=a+1,b=b+2,c=c+3);

// 相当于

a=a+1;

b=b+2;

c=c+3;

y=c;

# 优先级

从高到低

# 混合运算的类型转换

• C++ 中允许相关的数据类型进行混合运算

相关类型

尽管在程序中的数据类型不同，但逻辑上进行这种运算是合理的

• 相关类型在混合运算时会自动进行类型转换，再计算

# 算术转换原则

确保计算值的精度，转换后尽可能不丢失有效数字。

short ，2 字节，能表示的数小
int ，4 字节，能表示的数大
int 转 short ，要丢掉 2 字节的信息，不可取
short 转 int ，增加存储空间，但不丢失信息，可行

# 算术转换方式

• 字节少的向字节多的转换
  char , unsigned char , short , unsigned short , bool ➡️ int

cout<<('a'+5)<<endl;//'a' 转换为 int 再加 5，结果为整型

• 精度低的向精度高的转换
  int ➡️ float ➡️ double

cout<<(5+3.5)<<endl; // 5 转换为 double 型再相加，结果为 double

• 有符号向无符号转换
  int ➡️ unsigned int

unsigned int ui=32678;

cout<<(5+ui)<<endl; //5 转换为 unsigned int

# 隐式转换时机

1. 混合类型的表达式

char 和 int 相加，是字符的 ASCII 和整数相加。

int n=2;

char c='a';

cout<<(c+n)<<endl; //'a' 的 ASCII 为 97，加 2 得整型 99

2. 赋值

向左值类型转换

doube a=8.12;

int k;

k=a;//a 转换为 int，舍去小数，k 为 8

double 赋值给 int, 会舍去小数
向低精度转换 会 损失有效数字

整型 / 整型 = 整型，3/2=1, 而不是 1.5
整型相除，结果为整型，小数会被舍去。

int a=256+97;

double b=256+97.625;

char c1,c2;

c1=a; // 不推荐

c2=b; // 不推荐

3. 在需要关系、逻辑表达式的地方
   非 0 转 true；0 转 false

# 显式转换

程序中明确标记转换的类型，就是显式转换，也就是强制类型转换

<类型> (<表达式>)

(<类型>) <表达式>

优先级：高于乘法和除法，和逻辑非、按位取反同级
结合顺序：从右向左

double a=128,b=30;

int n=3;

a=(double)n/2;// 强制将 n 转换为 double

n=int(a/b); // 强制将 a/b 的值转换为 int

# 重点难点

# 整数、字符

# 整数

• 整数常量

• 整型变量

int a,b;

int x=10,y=20;

# 字符

• 字符常量

• 字符变量

char c,d;

char e='A',f='\0121';

# 内存中存储形式

整数 1 在内存中存储的是其二进制形式： 00000000 00000000 00000000 00000001
字符 '1' 在内存中存储的是 1 这个字符的 ASCII 码值，即 49 ，其二进制形式是 0011 0001 ，实际也是个整数，只占一个字节！

#include <iostream>

using namespace std;

int main() {

	int a,b;

	int x=10,y=20;

	char c,d;

	char e='A',f='\121';

	a=e+2; // 即 65+2 = 67

	e=98; // 即 'b'

	cout<<a<<" "<<e<<endl;

	return 0;

}

• 整数和字符在内存中都是整数。
  • 整数，存放数的二进制形式。
  • 字符，存放其 ASCII 码值。
• 输出时，
  • 当整数看待，显示数的十进制形式。
  • 当字符看待，显示的是 ASCII 值是这个数的字符（该数 < 128）。

int a=65; // 等同于 int a='A';

cout<<a<<endl; //65

cout<<(char)a<<endl; //A

char c='a'; // 等同于 char c=97;

cout<<c<<endl; // a

cout<<int(c)<<endl; //97

可以给整型变量赋字符值，也可以给字符变量赋整数值，关键是输出时把它们当什么看待。

# 字符串

• 字符串常量
  "zhang" , "wang" , "Hello world"

• 字符串 “变量”

char name[40]="zhang";

# 内存中存储形式

内存中， name 称为字符数组，最多可放 40 个字节大小的字符。

name 中的每一个字符可以通过 name[i] 下标来表示， i=0,...n-1 。
n 是字符串的长度，对 "zhang" 来说，n=5

int i=0,k;

name[i]='c';

cout<<name[i]<<endl;

k=name[i]-'a'+1; // 这里的 'a' 等同于 97

cout<<k<<endl;

# 转义字符

• 可显示字符，可以键盘直接输入

char c='A';

• 不可显示字符，不能直接输入
  ASCII 码值在 0-32 之间的字符是控制符号，不能显示到屏幕，是不可显示字符。

char d='\n';

cout<<"zhang"<<d<<"xjtu"<<endl;

cout<<"zhang\nxjtu\n";

• C++ 中，单引号表示字符，双引号表示字符串，反斜杠表示转义
  如需要显示，则单引号 \' ，双引号 \" ，反斜杠 \\

• 表示八进制、十六进制
  \ + 三位数字 (0-7)：八进制 ASCII，数值上小于 128，如 \ddd ： \ + ddd 八进制 ASCII
  \x + 两位数字 (0-9) 或字母 (A-F)：十六进制 ASCII，如 \xhh ： \x + hh 十六进制 ASCII

  \n \12 \x0A 表示换行
  \41 \041 \x21 表示 '!'
\60 \060 \x30 表示字符 '0'
\101 \x41 表示 'A'
\141 \x61 表示 'a'
\7 \07 \007 \x7 表示响铃

  	#include <iostream>
  	using namespace std;
  	int main()
  	{
  	cout<<'\41'<<'\041'<<'\x21'<<endl; // '!'
  	cout<<'\60'<<'\060'<<'\x30'<<endl; //'0'
  	cout<<'\n'<<'\12'<<'\x0A'; // 换行
  	cout<<'\101'<<'\x41'<<endl; //'A '
  	cout<<'\141'<<'\x61'<<endl; //'a'
  	cout<<'\7'<<endl; // 响铃
  	return 0;
  	}

# 常见转义符

回车：回到本行开头
换行：换到下一行开头

# 课堂讨论

1. 说说数据和数据类型的区别和联系？为什么要有数据类型？

• 区别：
  数据：具体的数字或字符，如 1 2 3 等等。
  数据类型：是对数据的分类，包括整型、浮点型、字符型、布尔型等。
• 联系：
  数据类型是具有相同性质数据的一个集合。
• 为什么要有数据类型？
  有了数据类型，可以将数据进行分类。分成所需内存大小不同的数据，可节省空间、充分利用内存，加快电脑的编译速度。

2. 整数，有符号，在计算机中是如何存储的？

• 计算机中整数是以二进制补码形式进行存储的。

• 计算机中将整数分为无符号整数 (unsigned) 和有符号整数 (signed)。

  • 对于无符号整数，它的原码、反码、补码都是相同的，直接采用其二进制形式表示即可。
  • 对于有符号整数，规定取最高位作为其符号位，若最高位为 0 表示正数，否则为负数。
    其原码、反码、补码之间的关系是：反码等于原码除符号位全部取反；补码等于反码 + 1。

  例子：

  • 计算机中存一个字节的 1 ：
    0 ^符号位 000000 ^{补足的 0} 1 ^{1 的二进制值}
    正数存的其实也是补码，不过正数的补码即是它本身
    所以计算机就存： 00000001
  • 计算机中存一个字节的 -1 ：
    先取 +1 的值：
    0 ^符号位 000000 ^{补足的 0} 1 ^{1 的二进制值}
    取反：
    1 ^取反 111111 ^取反 0 ^取反
    取补码：即反码 + 1
    1 111111 1
    所以计算机就存： 11111111

3. 什么是浮点数？浮点数在计算机中是如何存储的？

• 浮点数是属于有理数中某特定子集的数的数字表示，在计算机中用以近似表示任意某个实数。
• 浮点数的存储有单精度 float 类型和双精度 double 类型，这两种数据类型都是遵循 IEEE 标准的，float 以 32 位长度存储数据，double 以 64 位长度存储数据。
• 两种存储类型的基本格式是一致的，都是使用二进制科学表示法。
  二进制科学表示法的公式为：S=M*2^N ，即数据主要由三部分构成：符号位 ^{0 正 1 负} + 阶码^{指数位 N 采用移位存储} + 尾数位 ^M。
  • float 型数据，其二进制有 32 位，其中符号位 1 位，阶码 8 位，尾数 23 位；
  • double 型数据，其二进制为 64 位，符号位 1 位，阶码 11 位，尾数 52 位。

4. 什么时候需要位运算？

• 需要快速清零：和 0 按位与。
• 保留指定位：和另一个二进制数按位异
• 判断奇偶：和 1 按位与，偶数为 0，奇数为 1
• 设定指定位的数据：给某一位取反，交换数值的时候。
• 乘以 2，除以 2
  i<<1 和 i>>1 的效率比 i*2 和 i/2 更高。
  i<<N 效率比 2^N 效率更高。

# 随堂练习

1. 32 位系统中，C++ 的 int 型数据占的空间一般为 字节。

   • 8
   • 2
   • 4
   • 10

2. 下列哪个是 C++ 语言的合法的字符常量 。

   • "\0"
   • '054'
   • '\x89'
   • '\092'

3. 设 n=10，i=4，则执行赋值运算 n=n%(i-1) 后，n 的值是 。

   • 0
   • 1
   • 2
   • 3

4. 自增、自减运算可以用于变量，也可以用于常量和表达式。

5. 下面哪一 C++ 语言表达式不能正确表示数学关系 a<x<=b 。

   • a<x&&x<=b
   • x<=b&& a<x
   • !(a>=x)&&!(x>b)
   • a<x<=b

6. 若有 a=1 ， b=2 ，则表达式 a+1==b 的值为 。

   • 0
   • 1
   • 2
   • 3

7. 在位运算中，操作数每右移一位，其结果相当于 。

   • 操作数乘以 2
   • 操作数除以 2
   • 操作数乘以 4
   • 操作数除以 4

8. n 目运算符的含义是 。

   • 对 n 个数据进行操作
   • 对 n 个数据进行加法
   • 对 n 个类型进行整合
   • 对 n 个类型进行转换

9. 若有 a=2 ， b=4 ， c=5 ，则条件表达式 a>b?a:b>c?a:c 的值为 。

   • 0
   • 2
   • 4
   • 5

10. 以下非法的赋值语句是 。

    • n=(i=2，++i);
    • j++;
    • ++(i+1);
    • x=j>0;

11. 有如下表达式 19/3*sqrt(4.0)/5 ，则该表达式值数据类型为 。

    • int
    • float
    • double
    • 不确定

# 单元测试

# 第 1 次

1. 设 x，y，z 为整型数，下列各式中，运算结果与 x=y=24 的表达式相同的是 。

   • x=y=(z=8,4*6)
   • x=y=z=8, 4*6
   • x- (y=z= 8),4*6
   • x=(y=z=8,4*6)

   • 逗号表达式的值是最后一个表达式的值，逗号表达式的优先级最低。连等时，等号的结合方向是自右向左的。先计算右边表达式的值，向左赋值，等号表达式的值是等号右边表达式的值。
   • 都是 8
   • 这里 x 没有被赋值，y、z 是 8
   • x 为 24，y、z 是 8

2. C++ 源程序中，以下说法不正确的是 。

   • 变量声明语句一定要给变量赋初值
   • Pci 和 pci 是两个不同的标识符
   • 表达式 1/4+1/4+1/4 的结果为 0
   • 逗号运算符的优先级最低

   变量可以先声明，后赋值。

3. 设下列变量均已正确声明为 int，下列选项中不正确的赋值表达式是 。

   • a=b+c=1
   • k = I == 1
   • a=1,b=2,c=3,k=4
   • n1 = n2 = n3

   等号左边被赋值的必须是变量，或者说是能被赋值的量（左值）。不能是表达式。表达式不能被赋值。1 不能赋给 b+c。
   B

4. 下列哪个是 C++ 语言的合法的字符常量 。

   • '\017'
   • '\771'
   • '\092'
   • '\01711'

   • 表示八进制 ASCII 值是 017 的字符
   • 超出 ASCII 值范围
   • 不是八进制
   • 八进制，应最多三位，数值 - 128 ~ 127, 0 ~ 255。

5. 当 a=6,b=5 时，语句 cout<<(a<=7 && a+b>8)<<endl; 的执行结果为 。

   • 0
   • false
   • true
   • 1

   尽管逻辑值是 true，但显示的数值是 1，不是 “true” 这个字符串。

6. 设 i=6 ， k=0 下列各式中，运算结果为 k=7 的表达式是 。

   • k=++i+k;
   • k=k+++i;
   • k=++k+(++i);
   • k=i+++k;

   看看运算符的优先级。

7. 下列不合法的变量名为 。

   • -student
   • _student
   • student_name
   • student0

   首字母以英文字母或下划线开头。

8. int x=3,y=4,z=5; 则值为 0 的表达式是 。

   • y%z>=y-z
   • x>y
   • x!=y+z>y-z
   • x<=y+1

   逻辑值 false 的数值是 0

9. 若 a 为 int 型变量，已定义，则 (a=5+3) 也是表达式，其值为 8。

   = 也是运算符，左边应是变量，其表达式的值是右边表达式的值。

10. 如果定义 int e=8; double f=6.4, g=8.9; ，则表达式 f+int(e/3*int(f+g)/2)%4 的值为 9.4。

    注意运算顺序和数据类型
    8.4

# 第 2 次

1. 设 x，y，z 为整型数，下列各式中，运算结果与 x=y=24 的表达式相同的是 。

   • x=(y=z=8,4*6)
   • x=y=(z=8,4*6)
   • x- (y=z= 8),4*6
   • x=y=z=8, 4*6

   • x 为 24，y、z 是 8
   • 逗号表达式的值是最后一个表达式的值，逗号表达式的优先级最低。连等时，等号的结合方向是自右向左的。先计算右边表达式的值，向左赋值，等号表达式的值是等号右边表达式的值。
   • 这里 x 没有被赋值，y、z 是 8
   • 都是 8

2. 设下列变量均已正确声明为 int，下列选项中不正确的赋值表达式是 。

   • a=b+c=1
   • n1 = n2 = n3
   • a=1,b=2,c=3,k=4
   • ++k

   等号左边被赋值的必须是变量，或者说是能被赋值的量（左值）。不能是表达式。表达式不能被赋值。1 不能赋给 b+c。

3. 下列不合法的变量名为 。

   • wang13
   • st%udent
   • _cppclass
   • s_student

   变量名组成只能由大小写字母、数字、下划线组成。

4. 下列哪个是 C++ 语言的合法的字符常量 。

   • '\01711'
   • '\092'
   • '\17'
   • "c"

   • 八进制，应最多三位，数值 - 128-127,0-255。
   • 不是八进制
   • 表示八进制 ASCII 值是 17 的字符
   • 这是字符串，不是字符

5. 当 a=6,b=5 时，语句 cout<<(a<=7 && a+b>8)<<endl; 的执行结果为 。

   • 0
   • 1
   • true
   • false

   尽管逻辑值是 true，但显示的数值是 1，不是 “true” 这个字符串。

6. 下列不合法的变量名为 。

   • %student
   • student0
   • _student
   • student_name

   首字母以英文字母或下划线开头。

7. 表达式 19/4*sqrt(4.0)/5 的值为 。

   • 1.6
   • 3.8
   • 1.2
   • 1.0

   注意数据类型和运算顺序。

8. int x=3,y=4,z=5; 则值为 0 的表达式是 。

   • x>y
   • x<=y+1
   • x!=y+z>y-z
   • y%z>=y-z

   逻辑值 false 的数值是 0

9. 若 x 为整型变量，j 为实型变量，当执行 x=(int)j; 语句后，j 也变为整型变量。

   [j 的值转为整型，类型不会变].mistake

10. 如果定义 int e=8; double f=6.4, g=8.9; ，则表达式 f+int(e/3*int(f+g)/2)%4 的值为 9.4。

    注意运算顺序和数据类型

# 编程作业

# 题目 1. 温度转换（20 分）

• 题目内容
  输入华氏温度，用下列公式将其转换为摄氏温度并输出。

  $$C=5/9*(F-32)$$

• 输入格式
  实数
• 输出格式
  转换后的摄氏温度，实数。
• 输入样例
  80
• 输出样例
  26.6667

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	double F, C;

	cin>>F;

	C = 5.0/9*(F-32);

	cout<<C<<endl; 

	return 0;

}

# 题目 2. 计算数学函数式的值（20 分）

• 题目内容
  编程求函数

  $$y=sin(x*x)/(1-cos(x))$$

  的值。
• 输入格式
  实数，大于 0.
• 输出格式
  实数
• 输入样例
  0.1
• 输出样例
  2.00163

提示：正弦和余弦三角函数的值是通过数学库函数 sin(x) （正弦）、 cos(x) （余弦）来计算，需要包含头文件 <cmath> 。

# 解题代码

#include <iostream>

#include <cmath>

using namespace std;

int main()

{

	double x, y;

	cin>>x;

	y = sin(x*x)/(1-cos(x));

	cout<<y<<endl; 

	return 0;

}

# 题目 3. 数据的简单统计（20 分）

• 题目内容
  编程实现，用户从键盘输入 3 个整数，计算并打印这三个数的和、平均值及平均值的四舍五入整数值。
  注意：输入的三个整数、它们的和、平均值的四舍五入值用整型变量表示，平均值用双精度变量表示。
• 输入格式
  三个整数，中间用空格隔开。
• 输出格式
  计算结果，整数、实数和整数，分别表示：和、平均值及平均值的四舍五入整数值，分三行输出。
• 输入样例
  3 6 8
• 输出样例
  17
  5.66667
  6

技巧提示：四舍五入：实数加 0.5，再取整（转换为 int 型数）。

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	int a, b, c, sum, round;

	double mean;

	cin>>a>>b>>c;

	sum = a + b + c;

	mean = sum/3.0;

	round = int(mean + 0.5);

	cout<<sum<<'\n'<<mean<<'\n'<<round<<endl; 

	return 0;

}

# 题目 4. 找零钱（20 分）

• 题目内容
  为顾客找零钱时，希望选用的纸币张数最少。例如 73 元，希望零钱的面值为五十元 1 张，二十元 1 张，一元 3 张。设零钱面值有五十元、二十元、十元、五元和一元，请编写程序，用户输入 100 以下的数，计算找给顾客的各面值的纸币张数，数据间以空格隔开。
• 输入格式
  一个小于 100、大于等于 0 的整数。
• 输出格式
  5 个整数，数据间用一个英文空格分隔。
• 输入样例
  73
• 输出样例
  1 1 0 0 3

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	int n, r, n50, n20, n10, n5, n1;

	cin>>n;

	n50 = n / 50;

	n20 = (r = n % 50) / 20;

	n10 = (r = r % 20) / 10;

	n5 = (r = r % 10) / 5;

	n1 = (r = r % 5) / 1;

	cout<<n50<<' '<<n20<<' '<<n10<<' '<<n5<<' '<<n1<<endl; 

	return 0;

}

# 题目 5. 小写转大写（20 分）

• 题目内容
  用户输入一个字符，如果是小写字母输出对应的大写字母，其他字符不转换。
• 输入格式
  一个字符
• 输出格式
  一个字符
• 输入样例
  d
• 输出样例
  D

提示：使用三目条件运算符 ...？... ：...

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	char a;

	cin>>a;

	a = (a >='A' && a <= 'Z') ? a : a - 32;

	cout<<a<<endl; 

	return 0;

}

# 基础练习

# 题目 1. 求过平面上两点的直线的斜率（10 分）

• 题目内容
  编写程序，输入平面上的两个点的坐标 (x1,y1), (x2,y2)，求过这两点的直线的斜率（设斜率不为无穷）。
• 输入
  两行数据，实数。第 1 行是 x1、y1，第 2 行是 x2、y2，数据间用空格隔开。
• 输出
  一个实数，表示斜率。
• 输入样例
  1 1
  2 2
• 输出样例
  1

提示：数据类型都用 double

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	double x1 = 0, y1 = 0;

	double x2 = 0, y2 = 0;

	cin>>x1>>y1;

	cin>>x2>>y2;

	cout<<(y2-y1)/(x2-x1)<<endl;

	return 0;

}

# 题目 2. 计算平面上两点之间的距离（10 分）

• 题目内容
  编写程序，输入平面上的两个点的坐标（x1,y1）,(x2,y2), 计算这两点之间的距离。
• 输入
  两行数据，实数。第 1 行是 x1、y1，第 2 行是 x2、y2，数据间用空格隔开。
• 输出
  一个实数，表示距离。
• 输入样例
  0 0
  1 1
• 输出样例
  1.41421

提示：数据类型用 double ，包含头文件 cmath ，计算公式：

distance=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);

distance=sqrt(distance);

# 解题代码

#include <iostream>

#include <cmath>

using namespace std;

int main()

{

	double x1 = 0, y1 = 0;

	double x2 = 0, y2 = 0;

	double distance;

	cin>>x1>>y1;

	cin>>x2>>y2;

	distance=(x2-x1)*(x2-x1)+(y2-y1)*(y2-y1);

	distance=sqrt(distance);

	cout<<distance<<endl;

	return 0;

}

# 题目 3. 判断大小写（10 分）

• 题目内容
  输入一个英文字母，判断大小写。大写输出 1，小写输出 0。
• 输入
  一个字母
• 输出
  1 或 0
• 输入样例 1
  A
• 输出样例 1
  1
• 输入样例 2
  a
• 输出样例 2
  0

提示：设输入的字母为 c，判断大写的条件是： c>='A' && c<='Z' ，然后使用条件运算符， 条件 ? cout<<1 : cout<<0;

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	char c;

	cin>>c;

	(c>='A' && c<='Z') ? cout<<1 : cout<<0;

	return 0;

}

# 题目 4. 判断数字（10 分）

• 题目内容
  输入一个英文字符，判断是否数字。是输出 1，不是输出 0.
• 输入
  一个字符
• 输出
  1 或 0
• 输入样例 1
  5
• 输出样例 1
  1
• 输入样例 2
  a
• 输出样例 2
  0

提示：字符类型用 char ，设输入的字母为 c，判断数字的是： c>='0' && c<='9' ，然后使用条件运算符， 条件 ? cout<<1 : cout<<0;

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	char c;

	cin>>c;

	(c>='0' && c<='9') ? cout<<1 : cout<<0;

	return 0;

}

# 题目 5. 判断闰年（10 分）

• 题目内容
  编写程序，输入年份，判断是否闰年。是，输出 “IsLeapYear”；“否”，输出 “NotLeapYear”。
• 输入
  一个正整数
• 输出
  “IsLeapYear” 或 “NotLeapYear”
• 输入样例 1
  2000
• 输出样例 1
  IsLeapYear
• 输入样例 2
  2018
• 输出样例 2
  NotLeapYear

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	int year;

	cin>>year;

	((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) ? cout<<"IsLeapYear" : cout<<"NotLeapYear";

	return 0;

}

# 题目 6. 求商和余数（10 分）

• 题目内容
  输入两个正整数，求它们的商和余数。例如，输入 18 和 10，则它们的商是 1，余数是 8。
• 输入
  两个正整数，用空格隔开。
• 输出
  商和余数，用空格隔开。
• 输入样例
  18 10
• 输出样例
  1 8

提示：使用 int 类型， / 用来求商， % 用来求余数。

# 解题代码

#include <iostream>

#include <cmath>

using namespace std;

int main()

{

	int a, b;

	cin>>a>>b;

	cout<<a/b<<' '<<a%b<<endl;

	return 0;

}

# 题目 7. 计算平均分取整（10 分）

• 题目内容
  某招聘面试，7 个专家给考生打分，编写程序，计算 7 个专家给分的平均分，取整。
• 输入
  7 个 [0,100] 内的整数，用空格隔开
• 输出
  一个整数，是四舍五入的平均分。
• 输入样例
  70 70 70 70 70 70 73
• 输出样例
  70

提示：四舍五入： y=int(x+0.5)

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	int a, b, c, d, e, f, g;

	cin>>a>>b>>c>>d>>e>>f>>g;

	cout<<int(((a+b+c+d+e+f+g)/7.0)+0.5)<<endl;

	return 0;

}

# 题目 8. 计算点到直线的距离保留两位小数（10 分）

• 题目内容
  直线方程：Ax+By+C=0
  编写程序，输入 A、B、C 和点 (x,y)，计算该点到直线的距离。
  点到直线的距离公式：

  $$d=\frac{|Ax+By+C|}{\sqrt{A*A+B*B}}$$

  其中 | z | 表示绝对值，程序中使用条件表达式，如： z<0 ? z=-z:z=z;

• 输入
  两行，第 1 行是直线方程的系数 A、B、C，用空格隔开。
  第 2 行是平面点的坐标 (x,y)，用空格隔开。

• 输出
  一个实数，表示点到直线的距离，最多保留两位小数，四舍五入。
  提示：保留两位小数： d=int(d*100+0.5)/100.00;

• 输入样例
  2 1 -10
  -1 2

• 输出样例
  4.47

提示：数据类型用 double ， d=int(d*100+0.5)/100.00; 分母的小数点不可少。

# 解题代码

#include <iostream>

#include <cmath>

using namespace std;

int main()

{

	double A, B, C, x, y, z, d;

	cin>>A>>B>>C;

	cin>>x>>y;

	z = A*x + B*y +C;

	z < 0 ? z = -z : z = z;

	d = z/sqrt(A*A + B*B);

	cout<<int(d*100+0.5)/100.00<<endl;

	return 0;

}

# 题目 9. 输入字符显示 ASCII 值（10 分）

• 题目内容
  编写程序，输入一个字符，显示其 ASCII 值。如输入 “A” 显示 65，输入 “a” 显示 97。
• 输入
  一个字符。
• 输出
  一个整数。
  提示：设 c 是字符，则 int(c) 就是其 ASCII 值， c+0 也是。
• 输入样例 1
  A
• 输出样例 1
  65
• 输入样例 2
  a
• 输出样例 2
  97

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	char c;

	cin>>c;

	cout<<int(c)<<endl;

	return 0;

}

# 题目 10. 输入整数显示 ASCII 字符（10 分）

• 题目内容
  编写程序，输入一个 0-127 之间的整数，显示对应的 ASCII 字符。
  提示：若 k 是整数，将它赋值给字符变量或使用 char(k) 就得到字符。注意，有些字符是不能在屏幕上显示出来的。
• 输入
  一个 0-127 之间的整数。
• 输出
  一个 ASCII 字符
• 输入样例 1
  65
• 输出样例 1
  A
• 输入样例 2
  97
• 输出样例 2
  a

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	int k;

	cin>>k;

	cout<<char(k)<<endl;

	return 0;

}

# 题目 11. 输入整数显示十六进制（10 分）

• 题目内容
  编写程序，输入一个非负整数，显示其十六进制形式。如输入 31，输出 1f。
• 输入
  一个非负整数。
• 输出
  一个十六进制数
  提示：设 n 是非负整数，则 cout<<hex<<n; 显示 n 的十六进制形式。
• 输入样例
  31
• 输出样例
  1f

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	unsigned int n;

	cin>>n;

	cout<<hex<<n<<endl;

	return 0;

}

# 题目 12. 输入整数显示十六进制和八进制（10 分）

• 题目内容
  编写程序，输入整数，显示其十进制、十六进制和八进制形式。如输入 - 31，输出：-31 -1f -37
• 输入
  一个整数，注意，可能是负数。
• 输出
  三个数，十进制、十六进制和八进制，用空格隔开。

提示：设输入的整数为 n。

1. 使用 ?: 条件运算符求绝对值赋给另一变量。
2. 十进制、十六进制和八进制形式，在输出前分别输出 dec ， hex ， oct ，如 cout<<oct<<m;
3. 如果 n 小于 0，先输出一个负号，不换行，再输出整数。
   注意，即使你知道了 if 语句，在这儿也不应该使用。

• 输入样例
  - 31
• 输出样例
  - 31 -1f -37

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	int n, m;

	bool f;

	cin>>n;

	m = (f = n < 0) ? -n : n;

	f ? cout<<'-', cout<<dec<<m : cout<<dec<<m;

	cout<<' '; 

	f ? cout<<'-'<<hex<<m : cout<<hex<<m;

	cout<<' ';

	f ? cout<<'-'<<oct<<m : cout<<oct<<m;

	return 0;

}

# 中级练习

# 题目 1. 加密（10 分）

• 题目内容
  输入 4 字符的单词（小写），将每个字母转换为其在字母表中的序号（00-25）输出（不够两位的前面补 0）。例如，输入 atom，输出 00191412
• 输入格式
  连续的四个小写字母，表示一个 4 字母单词。
• 输出格式
  8 个 0-9 的数字，中间无空格。
• 输入样例
  atom
• 输出样例
  00191412

提示：输出，用 <条件>?< 表达式 1>:< 表达式 2>。

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	char c[4];

	cin>>c;

	int n = c[0] - 'a';

	n < 10 ? cout<<'0'<<n : cout<<n;

	n = c[1] - 'a';

	n < 10 ? cout<<'0'<<n : cout<<n;

	n = c[2] - 'a';

	n < 10 ? cout<<'0'<<n : cout<<n;

	n = c[3] - 'a';

	n < 10 ? cout<<'0'<<n : cout<<n;

	return 0;

}

# 题目 2. 解密（10 分）

• 题目内容
  一个 8 位的整数。它的每两位代表一个字母在字母表中的序号（00-25）, 编写程序，输入一个 8 位的整数（不够 8 位的前面补 0），按上述规则将其转换为一个四字母的单词。例如输入 01112004，输出 blue。
• 输入格式
  8 位整数。
• 输出格式
  四字母单词。
• 输入样例
  01112004
• 输出样例
  blue

# 解题代码

#include <iostream>

using namespace std;

int main()

{

	int n;

	cin>>n;

	char c[4];

	c[3] = n % 1000 + 'a';

	c[2] = (n / 100) % 100 + 'a';

	c[1] = (n / 10000) % 100 + 'a';

	c[0] = (n / 1000000) + 'a';	

	cout<<c;

	return 0;

}

# 题目 3. 压缩存储（10 分）

• 题目内容
  使用一个 int 变量（一般为 4 字节），保存 4 个均不超过 255 的非负整数，输出这个 int 变量的值。例如输入 1 2 3 4，输出 16909060。
• 输入格式
  4 个不超过 255 的非负整数，中间用空格隔开。
• 输出格式
  一个整数。四个整数放在一个 int 变量中，当一个整数看待的值。
• 输入样例
  1 2 3 4
• 输出样例
  16909060

技巧提示：使用移位运算。

# 解题代码

#include<iostream>

using namespace std;

int main()

{

    int a,b,c,d,s;

    cin>>a>>b>>c>>d;

    a=a<<24;

    b=b<<16;

    c=c<<8;

    s=a+b+c+d;

    cout<<s;

    return 0;

}

#include<iostream>

using namespace std;

int main()

{

    int a,b,c,d;

    cin>>a>>b>>c>>d;

    cout<<((((((a<<8)|b)<<8)|c)<<8)|d);

    return 0;

}

# 题目 4. 石头剪刀布（10 分）

• 题目内容
  石头、剪刀、布分别用 1,2,3 表示。输入数字，输出相应的词，如果输入的数不是 1,2,3，输出 “不认识”。
• 输入格式
  整数
• 输出格式
  "石头"、"剪刀"、"布" 或 "不认识" 四个词之一。
• 输入样例
  1
• 输出样例
  石头

技巧提示：表示文字，使用 char shitou[10]="石头";
输出： cout<<shitou;
判断，用 <条件>?<表达式1>:<表达式2>

# 解题代码

#include<iostream>

using namespace std;

int main()

{

    int n;

    cin>>n;    

    char shitou[10] = "石头";

    char jiandao[10] = "剪刀";

    char bu[10] = "布";

    char unknown[10] = "不认识";

    n == 1 ? cout<<shitou : (n == 2 ? cout<<jiandao : (n == 3 ? cout<<bu : cout<<unknown));

    return 0;

}

# 题目 5. 排排坐分果果（10 分）

• 题目内容
  有 10 个人围坐一桌，10 个人的编号为 1-10，指定一个人 a 开始，再指定一个数 k，从 a 为 1 往下数，每数到 k，就给这个人发一个糖果，然后再从下一个人开始从 1 数到 k，再发一个糖果（循环往复）。例如从 2 号人开始，k 为 3 则 4 号为分到糖果的人，再往下数 7 号为分到糖果的人，再往下数 10 号为分到糖果的人。

  编写程序，输入起始人的编号和 k，输出前四个分到糖果的人。例如输入 2 3，输出 4 7 10 3

• 输入格式
  两个正整数，中间用空格隔开。第 1 个数的范围为 1-10。

• 输出格式
  输出，4 个整数，用一个空隔开，末尾无空格。

• 输入样例
  2 3

• 输出样例
  4 7 10 3

提示：考虑 % 运算符的使用。

# 解题代码

#include<iostream>

using namespace std;

int main()

{

    int a, k;

    cin>>a>>k;

    a = a - 1 + k;

    a = a > 10 ? a % 10 : a;

    cout<<a;

    a = a + k;

    a = a > 10 ? a % 10 : a;

    cout<<' '<<a;

    a = a + k;

    a = a > 10 ? a % 10 : a;

    cout<<' '<<a;

    a = a + k;

    a = a > 10 ? a % 10 : a;

    cout<<' '<<a;    

    return 0;

}