蓝桥杯之c++入门（一）【C＋＋入门】

目录

• 前言
• • [5. 算术操作符](#5. 算术操作符)
  • • [5.1 算术操作符](#5.1 算术操作符)
    • [5.2 浮点数的除法](#5.2 浮点数的除法)
    • [5.3 负数取模](#5.3 负数取模)
    • [5.4 数值溢出](#5.4 数值溢出)
    • [5.5 练习](#5.5 练习)
    • • [练习1：计算 ( a + b ) ⋆ c (a+b)^{\star}c (a+b)⋆c](#练习1：计算 ( a + b ) ⋆ c (a+b)^{\star}c (a+b)⋆c)
      • 练习2：带余除法
      • 练习3：整数个位
      • 练习4：整数十位
      • 练习5：时间转换
      • 练习6：小鱼的游泳时间
  • [6. 赋值操作符](#6. 赋值操作符)
  • • [6.1 连续赋值](#6.1 连续赋值)
    • [6.2 复合赋值符](#6.2 复合赋值符)
    • [6.3 练习](#6.3 练习)
    • • 练习1：账户余额
      • 练习2：交换值
  • [7. 类型转换](#7. 类型转换)
  • • [7.1 混合运算时的类型转换](#7.1 混合运算时的类型转换)
    • [7.2 赋值时类型转换](#7.2 赋值时类型转换)
    • [7.3 强制类型转换](#7.3 强制类型转换)
    • [7.4 练习](#7.4 练习)
    • • 练习1：计算成绩
      • 练习2：浮点数向零舍入
      • 练习3：打印字符ASCII
      • [练习4：打印字符 （前面做过）](#练习4：打印字符 （前面做过）)
  • [8. 单目操作符](#8. 单目操作符)
  • • [8.1 + + 8.1++ 8.1++ 和--](#8.1 + + 8.1++ 8.1++ 和--)
    • • [8.1.1 前置 + + ^{++} ++ 和 后置 + + ^{++} ++](#8.1.1 前置 + + ^{++} ++ 和 后置 + + ^{++} ++)
      • [8.1.2 前置-- 和 后置--](#8.1.2 前置-- 和 后置--)
    • [8.2 + 8.2+ 8.2+ 和 -](#8.2 + 8.2+ 8.2+ 和 -)
• 总结

---

前言

这期紧接着前面的，因为之前系统的学过c++，所以蓝桥杯中的c我们就过一遍即可；系统的C++请看C++专栏

---

5. 算术操作符

5.1 算术操作符

在写代码时候，一定会涉及到计算。为了方便运算，提供了一系列操作符，其中有一组操作符叫：算术操作符 。分别是： + − ⋆ / % +-\star/\% +−⋆/% ，这些操作符都是双目操作符。

注：操作符也被叫做：运算符，是不同的翻译，意思是一样的。

#include <iostream>
using namespace std;
int main()
{
 int a = 7 + 2; //加法运算
 int b = 7 - 2; //减法运算
 int c = 7 * 2; //乘法运算
 int d = 7 / 2; //除法运算，得到的是整除后的商
 int e = 7 % 2; //取余运算，得到的是整除后的余数
 
 cout << a << endl;
 cout << b << endl;
 cout << c << endl;
 cout << d << endl;
 cout << e << endl;
 
 return 0;
}
 

易错点：

• / 除法的操作符，除数不能为0，如果除数为0，程序会崩溃的。

• % 取模操作符的计算结果是两个操作数进行除法运算后的余数。

• 取模操作符的操作数只能是整型，不能是浮点型，这个编译器会报语法错误的。

#include <iostream>
using namespace std;
int main()
{
	int a = 1;
	int b = 0;
	int c = a / b;  //报错 
	
	cout << c << end;
	float d = 6.0;
	float e = d % 3;  // 报错 
	return 0;
}

如果我们在visual studio中运行会发现有这样的报错：

5.2 浮点数的除法

int main()
{
 float x = 6 / 4;
 cout << x << endl; // 1
 float y = 6.0 / 4; // 6/4.0结果是?样的
 cout << y << endl; // 1.5
 return 0;
}

上面示例中，尽管变量 x 的类型是 float （浮点数），但是 6 / 4 得到的结果是 1.0 ，而不是1.5 。原因就在于 整数除法是整除，只会返回整数部分，丢弃小数部分。

如果希望得到浮点数的结果，两个运算数必须至少有一个浮点数，这时就会进行浮点数除法。

5.3 负数取模

• 负数也是支持取模的，但是负数求模结果的正负号由第一个运算数（操作数）的正负号决定。

#include <iostream>
using namespace std;
int main()
{
 cout << 11 % -5 << endl; // 1
 cout << -11 % -5 << endl; // -1
 cout << -11 % 5 << endl; // -1
 return 0;
}

5.4 数值溢出

前面我们了解到数据类型都有对应的数值范围，而在实际运算过程中可能会存在加法操作导致数据范围超过当前数据类型规定的范围，如下：

//数值溢出 
int main()
{
 char a = 'Z';//90
 char b = a + 'Z';//90+90
 cout << b << endl; // 输出了不显?的内容
 
 //printf是格式化输出，后面章节会讲，这章暂不做讲解
 printf("%d", b); // -76，char的十进制进制内容
 return 0;
}

以 char 类型为例， char 的数值范围在 -128 ~ 127 ，当字符相加超过最大值后，打印出来的结果会变成负数，这与数据的存储有关；

char类型变量的取值范围 ：

小提示：

char类型变量的取值范围的规律也可以推演到其他类型 ;

意识到数据类型的取值是有其范围的，那么我们在编程的时候就要选择合适的数据类型，才能得到正确的结果。正所谓：十年 IO 一场空，不开 long long 见祖宗。

5.5 练习

练习1：计算 ( a + b ) ⋆ c (a+b)^{\star}c (a+b)⋆c

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

小提示：

这个题目一定能注意，数据范围， − 1 0 4 < a , b , c < 1 0 4 -10^{4}<a,b,c<10^{4} −104<a,b,c<104 ， ( a + b ) ⋆ c (a+b)^{\star}c (a+b)⋆c 的结果也不会超过有符号整型的最大值，而如果取值范围变成 − 1 0 5 < a , b , c < 1 0 5 -10^{5}<a,b,c<10^{5} −105<a,b,c<105 ，就需要使用 long long 类型了。

练习2：带余除法

#include <iostream>
using namespace std;
int a, b;
 
int main() 
{
 cin >> a >> b;
 cout << a / b << " " << a % b << endl;
}

练习3：整数个位

#include <iostream>
using namespace std;
int a;
int main() 
{
 cin >> a;
 cout << a % 10 << endl;
 return 0;
}

练习4：整数十位

#include <iostream>
using namespace std;
int a;
int main()
{
 cin >> a;
 cout << a % 100 / 10 << endl;
 return 0;
}

练习5：时间转换

#include <iostream>
using namespace std;
int t;
 
int main() 
{
    cin >> t;
    cout << t / 60 / 60 << " " << t / 60 % 60 << " " << t % 60 << endl; 
    return 0;
}

解释：

1. time除以60（1分钟有60秒）先换算出分钟数，分钟数除以60（1小时有60分钟）交换算成小时。
2. time除以60（1分钟有60秒）先换算出分钟数，分钟数对60取模，就是换完小时后剩余的分钟数
3. time对60取模，每60秒凑1分钟，还剩多少多少秒，没办法凑够一分钟。

练习6：小鱼的游泳时间

#include <iostream>
using namespace std;
int main()
{
    int a,b,c,d;
    cin >> a >> b >> c >> d;
    int h = (c*60 + d) - (a*60 + b);
    cout << h / 60 << " " << h % 60 << endl;
    return 0;
}

6. 赋值操作符

在变量创建的时候给一个初始值叫初始化，在变量创建好后，再给一个值，这叫赋值。

int a = 100; //初始化
a = 200; 

赋值操作符 = = = 是一个随时可以给变量赋值的操作符，赋值运算符是把右边的值赋值给左边的，这个和数学中的书写习惯是不同的。

6.1 连续赋值

赋值操作符也可以连续赋值，如：

int a = 3;
int b = 5;
int c = 0;
c = b = a + 3; //连续赋值，从右向左依次赋值的。

虽然支持这种连续赋值，但是写出的代码不容易理解，建议还是拆开来写，这样方便观察代码的执行细节。

int a = 3;
int b = 5;
int c = 0;
b = a + 3;
c = b;

这样写，在调试的时候，每一次赋值的细节都是可以很方便的观察的。

6.2 复合赋值符

在写代码时，我们经常可能对一个数进行自增、自减的操作，如下代码：

int a = 10;
a = a + 3;
a = a - 2;

这样代码 C + + \mathsf{C}\mathsf{+}\mathsf{+} C++ 给提供了更加方便的写法：

int a = 10;
a += 3;
a -= 2;

C + + \mathsf{C}\substack{++} C++ 中提供了复合赋值符，方便我们编写代码，这些赋值符有：

|-------|-----------|------------|
| 复合赋值符 | 样例 | 一般写法 |
| += | a +=10 | a=a +10 |
| 二 | a-=10 | a=a-10 |
| ★ | a*=10 | a=a*10 |
| /= | a /=10 | a=a/10 |
| %= | a %= 10 | a = a % 10 |
| vV= | a >>= 1 | 详见《第7章操作符》 |
| | a<<=1 | 详见《第7章操作符》 |
| &= | a&=10 | 详见《第7章操作符》 |
| = | a|=10 | 详见《第7章操作符》 |
| ^= | a^=10 | 详见《第7章操作符》 |

6.3 练习

练习1：账户余额

小明账户有100元，经过了下面的操作：

往里面存了10元购物花掉了20元把里面的钱全部取出

请在每次操作后输出账户余额：

#include <iostream>
using namespace std;
int main() 
{ 
 int balance = 100;
 
 balance += 10;
 cout << balance << endl;
 
 balance -= 20;
 cout << balance << endl;
 
 balance = 0;
 cout << balance << endl;
 
 return 0; 
}

小提示：

使用复合赋值操作符能够让代码更简洁，但需要注意，不要一味地追求代码简洁，过于简洁的代码在可读性上会差一些。

练习2：交换值

#include <iostream>
using namespace std;
int main()
{
 int a = 0;
 int b = 0;
 cin >> a >> b;
 
 int c = a; //c是⼀个临时变量，作为中间变量实现交换的
 a = b;
 b = c;
 cout << a << " " << b << endl;
 
 return 0;
}

7. 类型转换

在使用 C / C + + \mathsf{C}/\mathsf{C}++ C/C++ 写代码的过程中，不同类型的数据进行混合计算的时候，或者赋值时等号两边的类型不统一的时候，都会发生类型转换，这时就需要根据类型的转换规则转换成合适的类型。

7.1 混合运算时的类型转换

字符、整数、浮点数可以混合运算，在这种情况下首先要将不一致的数据类型进行转换，类型统一后才能进行计算。

这里边一般涉及两类转换：整型提升和算术转换。

整型提升：表达式之中的 char 和 short 类型一定会先转换成 int 类型，然后参与运算。

算术转换：表达式中出现下面的任意两种类型的值进行计算的时候，要先要将较下面的类型转换成另外一种类型才能计算。

long double
double
float
unsigned long int
long int
unsigned int
int

这些转换都是隐式自动发生的，有些编译器会报警告，写程序的人并没有感知到，也不需要操心细节。

#include <iostream>
using namespace std;
int main()
{
 //案例1
 char a = 'a';
 int b = 10;
 char c = a + b; //这⾥a会发⽣整型提升，a+b的结果存放到c中，⼜发⽣截断
 
 //案例2
 int c = 10;
 double d = 3.14;
 double e = c + d; //c+d的时候，这⾥c会发⽣算数转换，转换为double类型
 
 return 0;
}

7.2 赋值时类型转换

当赋值操作符两端的数据类型不一致的时候，这时就需要类型转换，这种转换也是隐式自动发生的。转换规则如下：

1. float 和 double 赋值给 int ，直接截断小数部分，保留整数部分。

int a = 3.14;//这⾥a得到的是3

2. 较小的类型转换较大类型，直接转换，值不变。
3. 较大的类型转换较小的类型，一般会发生截断，按照较小类型的长度，保留低位数据给较小的类型。

这些转换都是隐式自动发生的，有些编译器会报警告，写程序的人并没有感知到，也不需要操心细节。

7.3 强制类型转换

在 C / C + + \mathsf{C}/\mathsf{C}++ C/C++ 中也会有强制类型转换，根据实际的需要将某一数据的数据类型转换为指定的数据类型，强制类型转换是临时转换的，不影响变量本身的类型。语法形式如下：

 （类型名）表达式

例如：

double d = 3.14;
int a = (int)d;

上面的代码是将 double 类型的 3.14 转换成 int 类型的值，赋值给 a 。

7.4 练习

练习1：计算成绩

#include <iostream>
using namespace std;
int a,b,c;
int ret;
int main()
{
 cin >> a >> b >> c;
 ret = (int)(a * 0.2 + b * 0.3 + c * 0.5);
 //这⾥进⾏了强制类型转换，如果不转换，也会⾃动转换的
 cout << ret << endl;
 return 0;
}

练习2：浮点数向零舍入

#include <iostream>
using namespace std;
double x;
int main()
{
 cin >> x;
 cout << (long long)x << endl;
 //题⽬给的数据较⼤，强制转换为int，存在漏洞 
 return 0;
}

小提示：

这里也要注意， − 1 0 ∧ 15 ≤ x ≤ 1 0 ∧ 15 -10^{\wedge}15\leq x\leq10^{\wedge}15 −10∧15≤x≤10∧15 ，这个取值范围明显超过int的取值范围。

练习3：打印字符ASCII

#include <iostream>
using namespace std;
int main()
{
 char c = 0;
 cin >> c;
 cout << (int)c <<endl; 
 //如果没有强制类型转换，编译器会认为c是字符类型，打印的依然是字符
 return 0;
}

练习4：打印字符 （前面做过）

#include <iostream>
using namespace std;
int main()
{
 int n = 0;
 cin >> n;
 cout << (char)n <<endl; //利⽤强制类型转换，将ASCII码值按照字符类型打印
 return 0;
}

8. 单目操作符

前面介绍的操作符都是双目操作符，即有2个操作数。除此之外还有一些操作符只有一个操作数，被称为单目操作符。如 + + ^{++} ++ 、--、 + ^+ + (正)、-(负) 就是单目操作符。

8.1 + + 8.1++ 8.1++ 和--

• • ^{++} ++ 是一种自增的操作符，又分为前置 + + ^{++} ++ 和后置 + + ^{++} ++ ， -- 是一种自减的操作符，也分为前置 --和后置 --

请一定要注意：

前置 + + ^{++} ++ 或者 后置 + + ^{++} ++ ，都是让操作数自增1的前置 -- 或者 后置 -- ，都是让操作数自减1的

8.1.1 前置 + + ^{++} ++ 和 后置 + + ^{++} ++

1 //案例1

//案例1
int x = 10;
int a = ++x; //++的操作数是x，是放在x的前⾯的，就是前置++
cout << x << " " << a << endl;
//案例2
int x = 10;
int a = x++; //++的操作数是x，是放在x的后⾯的，就是后置++
cout << x << " " << a << endl;

小技巧：

前置 + + ^{++} ++ ： 先 + 1 +1 +1 ，后使用

后置 + + ^{++} ++ ：先使用，后 +1

8.1.2 前置-- 和 后置--

//案例1
int y = 10;
int b = --y; //--的操作数是y，是放在y的前⾯的，就是前置--
cout << y << " " << b << endl;
//案例2
int y = 10;
int b = y--; //--的操作数是y，是放在y的后⾯的，就是后置--
cout << y << " " << b << endl;

小技巧：

前置 --： 先 - 1，后使用

后置 --：先使用，后 - 1

8.2 + 8.2+ 8.2+ 和 -

这里的 + ^+ + 是正号， - 是负号，都是单目操作符。

运算符 + ^+ + 对正负值没有影响，是一个完全可以省略的运算符，但是写了也不会报错。

int a = +10; //等价于 int a = 10;

运算符 - 用来改变一个值的正负号，负数的前面加上 - 就会得到正数，正数的前面加上 - 会得到负数。

int a = 10;
int b = -a;
int c = -10;
cout << b << c << endl; //这⾥的b和c都是-10
int a = -10;
int b = -a;
cout << b << endl; //这⾥的b是10

完

---

总结

---