考纲

GESP C++ 一级考纲

一、计算机基础知识

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

二、变量

1.变量的声明

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

#include <iostream>

using namespace std;

int main()

{

int a; //声明一个变量a

cin>>a; //把输入的值给a变量

cout<<"a="<<a;

}

结果：

2.变量的声明且赋值

<code>#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：输出

<code>#include <iostream>

using namespace std;

int main()

{

cout<<"Hello World"<<endl; //endl：表示换行

cout<<"Hello C++"<<endl;

}

结果：

（2）cin：输入

<code>#include <iostream>

using namespace std;

int main()

{

int a; //声明一个变量a

cin>>a; //把输入的值给a变量

cout<<"a="<<a;

}

假如键盘输入6，结果：

（3）连续输入输出

<code>#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，因为它们提供了更好的类型安全性和扩展性。

<code>#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 类型的浮点数常量。

数据类型转换

<code>#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种算术运算符：

<code>#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种算术运算符优先级顺序如下：

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

<code>#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++中，用等号“=”表示一个赋值操作，这里的“=”就是赋值运算符。

<code>#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.复合赋值运算符

<code>#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.自增自减运算符

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

<code>++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。

<code>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后面的语句。

<code>#include<iostream>

using namespace std;

int main() {

cout << "请输入您的年龄：" << endl;

int age;

cin >> age;

if ( age >= 18 ) {

cout << "欢迎您，成年人！" << endl;

} else {

cout << "本程序不欢迎未成年人！" << endl;

}

}

结果：

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

<code>#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 …，具体形式如下：

<code>#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只需要给定一个判断条件，只要条件为真，就重复地执行语句。语法如下：

<code>while (条件){

语句

}

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

#include<iostream>

using namespace std;

int main() {

int i = 1;

while (i <= 3) {

cout<<i<<" ";

i++;

}

}

结果：

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

<code>第一次循环：

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语法如下：

<code>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循环的经典语法形式是：

<code>for (初始化语句; 条件; 表达式){

语句

}

for循环的执行顺序：

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

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

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

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

#include<iostream>

using namespace std;

int main() {

for (int i = 1; i <= 3; i++)

{

cout << i << " ";

}

}

结果：

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

执行顺序示意图：

<code>第一次循环：

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循环嵌套会多一些。

<code>#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;

}

}

}

结果：

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

<code>第一次外层循环：

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语句表示“继续”执行循环，也就是中断循环中的本次迭代，并开始执行下一次迭代。

<code>//需求：输出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;

}

}

}

结果：