GESP一级考试笔记（C++）

考纲

GESP C++ 一级考纲

一、计算机基础知识

世界上第一台可编程的电子计算机—ENIAC。

二、变量

1.变量的声明

• 想要使用变量，必须先做“声明”，也就是告诉计算机要用到的数据叫什么名字。变量声明的标准语法可以写成：数据类型 变量名;

#include <iostream>
using namespace std;
int main()
{
	int a; //声明一个变量a 
	cin>>a; //把输入的值给a变量
	cout<<"a="<<a;
} 

结果：

2.变量的声明且赋值

#include <iostream>
using namespace std;
int main()
{
	int a = 1; //声明变量a,并赋值为1 
	cout<<a; //结果：输出1
}

• 全局变量和局部变量

#include <iostream>
using namespace std;

// 全局变量
int number = 100;

int main()
{
	// 局部变量
	int number = 1;

	// 访问局部变量
	cout << "number = " << number << endl;
	// 访问全局变量，number前面要加上双冒号:: 
	cout << "number = " << ::number << endl; 

}
 

3.变量名的规则

• 【规则1】：变量名包含字母、数字、下划线，但数字不能在变量名首位，例如以下变量名：

a（合法）、a123（合法）、_xyz（合法）、2b（不合法，不能以数字开头）

• 【规则2】：具有特殊含义的单词不能作为变量名， 否则会报错，我们把这一类统称为关键字，它们在C++中已经代表了特定的意思，例如以下单词：

do, while, for, int, if, char, long, bool , double ,false , true 等等。

三、输入输出

• 在C++中，cin、cout、printf和scanf是用于输入输出的基本函数和流对象。它们的使用方式有一些区别，主要是因为cin和cout是基于C++的流（stream）库，而printf和scanf则是C语言风格的输入输出函数。

• cin 和 cout

（1）cout：输出

#include <iostream>
using namespace std;
int main()
{
	cout<<"Hello World"<<endl; //endl：表示换行
	cout<<"Hello C++"<<endl;
} 

结果：

（2）cin：输入

#include <iostream>
using namespace std;
int main()
{
	int a; //声明一个变量a 
	cin>>a; //把输入的值给a变量
	cout<<"a="<<a;
} 

假如键盘输入6，结果：

（3）连续输入输出

#include <iostream>
using namespace std;
int main()
{
	int a; //声明变量a 
	int b; //声明变量b
	cin>>a>>b; //输入a和b
	cout<<a<<" "<<b; //输出a和b 
} 

假如键盘输入2，回车再输入8，结果：

---

• printf 和 scanf

printf和scanf是C语言风格的输入输出函数，分别用于格式化输出和格式化输入。它们在C++中仍然被支持，但通常建议优先使用C++风格的cin和cout，因为它们提供了更好的类型安全性和扩展性。

#include <cstdio> // 或者使用 <stdio.h>，但推荐使用C++风格的头文件  
  
int main() {  
    int x;  
    printf("请输入一个整数: "); // 输出提示信息  
    scanf("%d", &x); // 从标准输入读取一个整数  
    printf("你输入的整数是: %d\n", x); // 输出读取到的整数  
    return 0;  
}

四、基本数据类型

• double和float的区别

float：属于单精度型浮点数据。通常占用4个字节的内存空间。
double：属于双精度型浮点数据。通常占用8个字节的内存空间。
【重点】：如果在代码中不明确指定浮点数的类型，则默认会被视为double类型。例如：

• 7 是一个 int 类型的整数常量。
• 7.0 是一个 double 类型的浮点数常量。
• 7.0f 是一个 float 类型的浮点数常量。

• 数据类型转换

#include <iostream>
using namespace std;
int main() {
	// 1. 整数值赋给bool整型
	bool b = 25; 
	cout<<"b="<<b<<endl;

	// 2. bool类型赋值给整型
	int s = false; 
	cout<<"s="<<s<<endl;
	
	// 3. 浮点数赋给整数类型
	int i = 3.14; 
	cout<<"i="<<i<<endl;
	
	// 4. 整数值赋给浮点类型
	float f = 10; 
	cout<<"f="<<f<<endl;
}

结果：

• 数据类型转换规则总结如下：

• 非布尔类型的算术值赋给布尔类型，初始值为0则结果为 false , 否则结果为true ；
• 布尔值赋给非布尔类型，初始值为 false 则结果为0，初始值为 true 则结果为1；
• 浮点数赋给整数类型，只保留浮点数中的整数部分，会带来精度丢失；
• 整数值赋给浮点类型，小数部分记为0。如果保存整数需要的空间超过了浮点类型的容量，可能会有精度丢失。

五、运算符

1.算术运算符

• C++中有5种算术运算符：
  

#include <iostream>
using namespace std;
int main()
{
	// 加法
	int a = 20, b = 6;
	cout << " a + b = " << a + b << endl;
	
	// 减法
	cout << " a - b = " << a - b << endl;
	
	// 乘法
	cout << " a * b = " << a * b << endl;
	
   	// 除法：注意 / 只保留整数部分
	cout << " a / b = " << a / b << endl;

	// 取模：两个数必须是整数类型
	cout << " a % b = " << a % b << endl;
} 

结果：

• 以上5种算术运算符优先级顺序如下：

运算符	优先级
* / %	三者并列，高于加减
+ -	两者并列

#include <iostream>
using namespace std;
int main() {
	//优先级比较
	int a = 20, b = 6,c = 10;
	cout << " a + c * b = " << a + c * b << endl;
	cout << " a % b * c = " << a % b * c << endl;
	cout << " a / b % c = " << a / b % c << endl;
	cout << " a * b / c = " << a * b / c << endl;
}

结果：

• 算术表达式：由算术运算符和数字组成的式子，例如a + 1，a + b * c等等。

3.赋值运算符

• 在C++中，用等号“=”表示一个赋值操作，这里的“=”就是赋值运算符。

#include <iostream>
using namespace std;
int main() {
	int a = 20;//把20赋值给a变量 
	cout << " a = " << a << endl;
	int c = a = 100;    // 连续赋值:把100重新赋值给a变量,再把a变量的值赋值给c变量 
	cout << " c = " << c << endl;
}

结果：

4.复合赋值运算符

#include <iostream>
using namespace std;
int main() {
	int x = 6,y = 2;
	y+=x; //等价于 y = y+x; 即先计算y+x的结果，再把结果赋值给y，以下同理 
	cout<<"y="<<y<<endl;
	x-=5;
	cout<<"x="<<x<<endl;
	x/=y;
	cout<<"x="<<x<<endl;
}

结果：

5.自增自减运算符

• “自增”用两个加号“++”表示，表示“对象值加一，再赋值给原对象”；“自减”则用两个减号“–”表示。

++a;    // a自增，相当于 a += 1;
--b;    // b自减，相当于 b -= 1;

• 自增自减运算符各自有两种形式：“前置”和“后置”，也就是说写成“++a”和“a++”都是可以的。它们都表示“a = a + 1”，区别在于表达式返回的结果不同：

• 前置时，对象先加1，再将更新之后的对象值作为结果返回；
• 后置时，对象先将原始值作为结果返回，再加1；

#include <iostream>
using namespace std;
int main() {
	int x = 3;
	int y = ++x;//先让x自增1，再将x更新后的结果赋值给y
	cout<<"x="<<x<<endl;
	cout<<"y="<<y<<endl;

	int a = 3;
	int b = a++;//先将a赋值给b,再让a自增1
	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
}

结果：

6.关系运算符

• 关系运算符：两个表达式可以使用关系运算符进行比较，运算结果是布尔类型值：true或false。
  

1 < 2;    // true
3 >= 5;    // false
10 == 4 + 6;    // true
(10 != 4) + 6;    // 7 原因：关系运算符的返回值为布尔类型，如果参与算术计算，true的值为1，false的值为0；

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

7.逻辑运算符

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

• 逻辑非（!）：将运算对象的值取反后返回；
• 逻辑与（&&）：两个运算对象都为true时结果为true，否则结果为false；
• 逻辑或（||）：两个运算对象只要有一个为true结果就为true，都为false则结果为false；

1 < 2 && 3 >= 5;    // false
1 < 2 || 3 >= 5;    // true
!(1 < 2 || 3 >= 5);    // false

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

#include <iostream>
using namespace std;
int main() {
	int i = -1;
	1 < 2 && ++i; // false
	cout << " i = " << i << endl; // i = 0
	1 < 2 || ++i; // true
	cout << " i = " << i << endl; // i = 0
}

8.条件运算符

• “条件运算符”：由“?”和“:”两个符号组成，需要三个运算表达式，形式如下：

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

条件运算符的含义是：计算条件判断表达式的值，如果为true就执行表达式1，返回求值结果；如果为false则跳过表达式1，执行表达式2，返回求值结果。

#include <iostream>
using namespace std;
int main() {
	int i = 0;
	cout << ((1 < 2 && ++i) ? "true" : "false") << endl; //结果：true 
}

注意：条件运算符的优先级比较低，所以输出的时候需要加上括号。事实上，条件运算符等同于流程控制中的分支语句if…else…，只用一条语句就可以实现按条件分支处理，这就让代码更加简洁。

---

9.总结：运算符的优先顺序

运算符说明	C++运算符	优先级顺序
小括号	( )	高——>低
逻辑非运算符、自增自减运算符	！++ - -
算术运算符	* / %
算术运算符	+、-
关系运算符	>、>=、<、<=
关系运算符	==、!=
逻辑与运算符	&&
逻辑或运算符	||
赋值运算符	= 、+=、 -= 、*= 、/=、 %=

六、if条件判断

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

1.单分支

#include<iostream>
using namespace std;
int main() {
	cout << "请输入您的年龄：" << endl;
	int age;
	cin >> age;
	if ( age >= 18 ) {
		cout << "欢迎您，成年人！" << endl;
	}
}

结果：

2.双分支

• 双分支就是在if分支的基础上，加了else分支；条件为真就执行if后面的语句，条件为假就执行else后面的语句。

#include<iostream>
using namespace std;
int main() {
	cout << "请输入您的年龄：" << endl;
	int age;
	cin >> age;
	if ( age >= 18 ) {
		cout << "欢迎您，成年人！" << endl;
	} else {
		cout << "本程序不欢迎未成年人！" << endl;
	}
}

结果：

3.多层嵌套分支if … else …

#include<iostream>
using namespace std;
int main() {
	cout << "请输入您的年龄：" << endl;
	int age;
	cin >> age;
	if ( age >= 18 ) {
		cout << "欢迎您，成年人！" << endl;
		if (age < 35) {
			cout << "加油，年轻人！" << endl;
		}
	} else {
		cout << "本程序不欢迎未成年人！" << endl;
		if (age >= 12) {
			cout << "少年，好好学习！" << endl;
		} else {
			cout << "小朋友，别玩电脑！" << endl;
		}
	}
}

结果：

4.多层嵌套分支if … else if…

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

#include<iostream>
using namespace std;
int main() {
	cout << "请输入您的年龄：" << endl;
	int age;
	cin >> age;
	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;
	}
}

结果：

七、循环

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

1.while循环

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

while (条件){
	语句
}

需求1：输出1~3之间所有的整数，并用空格隔开。

#include<iostream>
using namespace std;
int main() {
	int i = 1;
	while (i <= 3) {
		cout<<i<<" "; 
		i++;
	}
}

结果：

分析代码：拆解以上while循环的执行过程

第一次循环：
	i = 1; //i的初始值为1
	i <= 3 //条件成立，执行循环体中的语句
		cout << i << " "; //此时输出1
		i++; //i的值变为2
第二次循环：
	i = 2; //因为第一次循环结束后，i的值变为2
	i <= 3 //条件成立，执行循环体中的语句
		cout << i << " "; //此时输出2
		i++; //i的值变为3
第三次循环：
	i = 3; //因为第二次循环结束后，i的值变为3
	i <= 3 //条件成立，执行循环体中的语句
		cout << i << " "; //此时输出3
		i++; //i的值变为4
第四次循环：
	i = 4; //因为第三次循环结束后，i的值变为4
	i <= 3 //条件不成立，本次循环体并不会执行，也就是循环到此终止了

需求2：计算出1~10之间所有整数的和。

#include<iostream>
using namespace std;
int main() {
	int sum = 0;
	int i = 1;
	while (i <= 10) {
		sum += i;
		i++;
	}
	cout<<"sum="<<sum;
}

结果：

2.do while循环

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

do {
	语句
} while (条件);

需求1：输出1~10之间所有的整数，并用空格隔开。

#include<iostream>
using namespace std;
int main() {
	int i = 1;
	do {
		cout<<i<<" ";
		i++;
	} while(i<11);
}

结果：

3.for循环

• for循环的经典语法形式是：

for (初始化语句; 条件; 表达式){
	语句
}

• for循环的执行顺序：

for语句头中有三部分，用分号分隔，主要作用是：

• 初始化语句负责初始化一个变量，这个变量值会随着循环迭代而改变，一般就是“循环变量”。
• 中间的条件是控制循环执行的关键，为真则执行下面的循环体语句，为假则退出。
• 最后的表达式会在本次循环完成之后再执行，一般会对循环变量进行更改；

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

需求1：输出1~3之间所有的整数，并用空格隔开。

#include<iostream>
using namespace std;
int main() {
	for (int i = 1; i <= 3; i++)
	{	
		cout << i << " ";
	}
}

结果：

分析代码：拆解以上for循环的执行过程

执行顺序示意图：

第一次循环：
	i = 1; //i的初始值为1
	i <= 3 //条件成立，执行循环体中的语句
		cout << i << " "; //此时输出1
	i++; //i的值变为2
第二次循环：
	i = 2; //因为第一次循环结束后，i的值变为2
	i <= 3 //条件成立，执行循环体中的语句
		cout << i << " "; //此时输出2
	i++; //i的值变为3
第三次循环：
	i = 3; //因为第二次循环结束后，i的值变为3
	i <= 3 //条件成立，执行循环体中的语句
		cout << i << " "; //此时输出3
	i++; //i的值变为4
第四次循环：
	i = 4; //因为第三次循环结束后，i的值变为4
	i <= 3 //条件不成立，本次循环体并不会执行，也就是循环到此终止了

需求2：计算出1~10之间所有整数的和。

#include<iostream>
using namespace std;
int main() {
	int sum = 0;
	for (int i = 1; i <= 10; i++)
	{	
		sum += i;
	}
	cout<<"sum="<<sum;
}

结果：

4.循环嵌套

• 循环语句和分支语句一样，也是可以进行嵌套的。具体可以while循环中嵌套while，可以for循环中嵌套for，也可以while、do while和for混合嵌套。因为for的循环变量定义更明确，所以一般用双for循环嵌套会多一些。

#include<iostream>
using namespace std;
int main() {
	for (int i = 0; i < 2; i++) { //外层循环 
		for (int j = 0; j < 3; j++) { //内层循环
			cout << "Hello World!" << endl;
		}
	}
}

结果：

分析代码：拆解以上循环嵌套的执行过程

第一次外层循环：
	i = 0; //i的初始值为0
	i < 2  //条件成立，进入内层循环
		第一次进入内层循环：
			【内层循环第一次：】
			j = 0; //j的初始值为0
			j < 3  //条件成立
				cout << Hello World! << endl; //此时输出一次 Hello World!
			j++; //j的值变为1
			【内层循环第二次：】
			j = 1; 
			j < 3  //条件成立
				cout << Hello World! << endl; //此时输出一次 Hello World!
			j++; //j的值变为2
			【内层循环第三次：】
			j = 2; 
			j < 3  //条件成立
				cout << Hello World! << endl; //此时输出一次 Hello World!
			j++; //j的值变为3
			【内层循环第四次：】
			j = 3; 
			j < 3  //条件不成立，内层循环结束
	i++; //i的值变为1
第二次外层循环：
	i = 1; 
	i < 2  //条件成立，进入内层循环
		第二次进入内层循环：
			【内层循环第一次：】
			j = 0; //j的初始值为0
			j < 3  //条件成立
				cout << Hello World! << endl; //此时输出一次 Hello World!
			j++; //j的值变为1
			【内层循环第二次：】
			j = 1; 
			j < 3  //条件成立
				cout << Hello World! << endl; //此时输出一次 Hello World!
			j++; //j的值变为2
			【内层循环第三次：】
			j = 2; 
			j < 3  //条件成立
				cout << Hello World! << endl; //此时输出一次 Hello World!
			j++; //j的值变为3
			【内层循环第四次：】
			j = 3; 
			j < 3  //条件不成立，内层循环结束
	i++; //i的值变为2
第三次外层循环：
	i = 2; 
	i < 2  //条件不成立，外层循环结束，整个循环都终止了

练习：九九乘法表

八、语句跳转

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

1.break

• 当代码中遇到break时，会直接中断距离最近的循环，跳转到外部继续执行。

#include <iostream>
using namespace std;
int main() {
	int i = 1;
	while (true) {
		cout << " 这是第" << i << "次输出" << endl;
		i++;
		if (i > 5) {
			break;
		}	
	}
}

结果：

2.continue

• continue语句表示“继续”执行循环，也就是中断循环中的本次迭代，并开始执行下一次迭代。

//需求：输出1到10之间所有的整数，5不输出

#include <iostream>
using namespace std;
int main() {
	for(int i = 1; i<=10; i++) {
		if (i == 5) {
			continue;
		} else {
			cout << "这是第" << i << "次输出" << endl;
		}
	}
}

结果：