【C++】程序设计期末复习 day01（连更）基础知识点和题目

写在开头：

这篇博客是在记录我自己复习c++的路上觉得比较重要的部分，并且比较简单，备考大家还是要多多敲代码，光看没有用的哈，除此之外希望能给大家一个比较好的复习思路。希望能帮助到大家。

下一期更新类和对象，以及更多结构体相关习题

一、思维导图

接下来的每一天将根据这个顺序来更新，后面估计更新题目会比较多，难题我会标注可以不用做

附有知识点笔记+题库（都是我自己找的嗷）各位同学可以有取舍地看一下，不懂得欢迎留言

以下思维导图来自学姐：

二、期末考试题型

• 改错题（每小题5分，共20分） 给定一段程序，需要大家指出错误、并改正。
• 程序填空题（每空5分，共25分） 补充缺失的代码。注意题目中留空的大小。 
• 程序分析题（每小题5分，共20分） 根据给定的代码，写出运行结果、功能等等。
• 程序设计题（每小题10分，共20分） 按给定要求，直接写出代码。 
• 应用题（15分） 按给定要求，直接写出代码。比上题复杂一些。

注：改错题一般错误会出现在语法，需要对c++基本写法熟记于心；程序填空题目我猜应该是给运行结果补充一些数据类型之类的，或者是补充循环条件（for、while）等等；程序分析题会给出一个框，读懂代码即可，估计就是简单的计算和输出；程序设计题比如像输出一个三角形之类的题目，不会太难，应用题不知道考啥，估计和平时作业差不多，就是根据一个背景设计程序。

在第四部分会带大家一起练习。

三、知识点复习

1.基础语法

  一个c++程序需要有头文件，一个主函数，and其他函数and数据类型，返回值，注意看注释内容

#include <iostream>//库文件
using namespace std;//声明命名空间std
//写这两行是为了使用iostream 库中的，std命名空间内的cout和cin

int main() {
    int a;//声明a的类型为int--整型变量
    cout<<"1"<<endl;//输出流
    cin>>a;//输入流
    //此处为单行注释
/*    
    此处为一个多行注释

*/

    return 0;//此处为一个返回值，因为主函数是int类型，故需要一个数字返回值
}

这里可能会有一个考点：变量命名是否合法（在改错题中）

不要死记，想想你自己怎么写变量的

1）变量名中不能包含". : ," ' + -"这些特殊符号（就是不要有符号，只能有下划线！！）

      比如可以是my_str,但不能是my-str

2）变量名不可以用数字开头 比如52select

3）变量名中间不能有空格

4）不能是c++关键字：比如case、auto、for、else...

名字空间：

• std是C+ +标准命名空间，C+ +标准程序库中的所有标识符都被定义在std中，比如标准库中的类iostream. vector等 都定义在该命名空间中，使用时要加上using声明(using namespace std)或using指示(如std::cout)

在库文件中使用名字空间的作用：

1. 避免命名冲突：库文件可以将其所有组件放入一个命名空间中，这样用户在使用库时，可以通过命名空间限定符访问库的组件，从而避免与用户代码中的其他同名组件发生冲突。

 2.数据类型

1）整型（就是整数类型的意思）

• int - 占4个字节
• unsigned int - 无符号整型，占4个字节
• long int-长整型，4个字节

2）sizeof关键字

• 利用sizeof关键字可以统计数据类型所占内存大小

#include<iostream>
using namespace std;
int main(){
    int a[5]={1,2,3,4,5};//这里定义了一个整型数组，包含五个数字
    cout<<sizeof(int);//输出为4 
    cout<<sizeof(a);//输出为20，因为计算的是整个数组的字节数 
    cout<<sizeof(a)/sizeof(int);//输出为5 
    cout<<sizeof(a)/sizeof(a[0]);//输出为5 
    return 0;
}

3）浮点型

• 用于表示小数

• 单精度float-占4个字节
• 双精度double-占8个字节

4）数值型常量

• 十进制整数。如1357,-432，0等
• 八进制整数。在常数的开头加一个数字0，就表示这是以八进制数形式表示的常数。如：0123
• 十六进制整数。在常数的开头加一个数字0和一个英文字母X(或x)，就表示这是以十六进制数形式表示的常数，如0x123、0X123 

5）字符

字符型：显示单个字符 char ch ='a'(用单引号）【\n之类的也是一个字符】

字符串型：字符串 string s = "ABC"(要写：#include<string>）

因为string是c++中的一个类，需要声明他所在的库文件

6）布尔型bool

bool类型只有两个值：

• true — 真（本质是1）
• false — 假（本质是0）

7）常量 

注意一下，常量不能写在函数的赋值语句的左边，比如以下这个max函数要程序运行后才有值，所以const写在右边才合法

常量定义必须初始化，不可被更改

const int a = sizeof(int);//合法,sizeof是内置操作符
const int a = max(15,32);//不合法

3.运算符 

1）算数运算符

*	乘	10 * 5	50
/	除	10 / 5	2
%	取模(取余)	10 % 3	1
++	前置递增	a=2; b=++a;	a=3; b=3;
++	后置递增	a=2; b=a++;	a=3; b=2;
--	前置递减	a=2; b=--a;	a=1; b=1;
--	后置递减	a=2; b=a--;	a=1; b=2;

注：前置和后置的意思就是说，先和后！

比如a++，先把a作为值，再执行+1操作

++a，先让a+1，也就是已经给a赋了新的值

2）赋值和比较运算符很简单，此处略去

3）逻辑运算符

运算符	术语	示例	结果
!	非	!a	如果a为假，则!a为真； 如果a为真，则!a为假。
&&	与	a && b	如果a和b都为真，则结果为真，否则为假。
||	或	a || b	如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

  我觉得不是很重要，用的不多，一般是写if语句会用到，比如说写 if（a&&b）：意思就是a和b都为真就运行if语句内容，if（a||b)就是说只要有一个为真，就运行

4.过程化语句（控制及循环）

1）if语句

说实话我感觉必考一个，很简单了，自己注意一下即可。if else

2）三目运算符

语法：表达式1 ? 表达式2 ：表达式3

如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

3）switch语句

作用：执行多条件分支语句

可以考switch和if else语句相互转换？我猜

switch (expression) {
    case a:
        // 相当于if a：
        break;
    case b:
        // 相当于else if b:
        break;
    ...
    default:
        //相当于else
}

具体的例子：注意switch中传递的参数只能是整型或者字符型

int option = 2; // 假设这是用户输入的选项
switch (option) {
    case 1:
        std::cout << "选项 1 被选择" << std::endl;
        break;
    case 2:
        std::cout << "选项 2 被选择" << std::endl;
        break;
    case 3:
        std::cout << "选项 3 被选择" << std::endl;
        break;
    default:
        std::cout << "无效的选项" << std::endl;
}

4）while 语句

• 作用：满足循环条件，执行循环语句
• 语法：while(循环条件){ 循环语句 }
• 解释：只要循环条件的结果为真，就执行循环语句

5）do…while

• 作用： 满足循环条件，执行循环语句
• 语法： do{ 循环语句 } while(循环条件);记得这个while后面有分号！
• 注意：与while的区别在于do…while会先执行一次循环语句，再判断循环条件（这里常考两者区别，记住无论怎样，do…while都会必然执行一次循环语句）

6）for

• for循环中的表达式，要用分号进行分隔(开始条件，判断条件，递加/减）

for(int i=0;i<5;i++){
    cout<<"1";
}
//将执行五次

5.函数

1）常用函数

• round（x）:对x进行四舍五入。 要记得写#include <cmath>

2）语法结构

• 函数定义里小括号内称为形参，函数调用时传入的参数称为实参

返回值类型 函数名 （参数列表）
{

       函数体语句

       return表达式

}

函数其实只要记得定义、声明、调用即可，写编程题会设计就行，这里不再赘叙细节

3）函数重载 

这里提一下重载，因为类中常用，可以理解一下

作用：函数名可以相同，提高复用性

函数重载满足条件：

• 函数名称相同
• 函数参数类型不同 或者 个数不同 或者 顺序不同

//这里用了结构体课上的代码，也就是说在结构体中的成员函数也可以重载！！只要参数不同
CNStrt::CNStrt() {
  real = 0;
  imag = 0;
};
 
CNStrt::CNStrt(double r) {
  real = r;
  imag = 0;
};
 
CNStrt::CNStrt(double r, double i) {
  real = r;
  imag = i;
};

4）指针传参（考的概率小）

• 如果不使用指针传参或者引用传参的话，对形式参数的任何操作都是对实际参数没有影响的。

//指针传参
#include<iostream>
using namespace std;
void swap(int* a, int* b);
int main() {
	int a = 0, b = 1;
	swap(&a, &b);//传递地址
	cout << a  << " " << b << endl;
}
void swap(int* a, int* b) {//指针接收
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

5）引用和引用传参 

在C++中，引用是一种特殊的变量类型，它本质上是一个别名，即另一个已存在变量的另一个名字。引用本身不占用内存空间，它只是提供了一种通过不同名称访问同一内存位置的方式。一旦引用被初始化指向某个变量后，它就不能被重新指向另一个变量。

以下是引用的一些关键特性：

1. 初始化：引用必须在声明时被初始化。一旦引用被初始化指向某个变量，它就不能被改变指向另一个变量。

2. 别名：引用是它所引用变量的别名。对引用的操作实际上是对原始变量的操作。

3. 语法：引用在声明时使用 & 符号，例如 int &ref = var;，这里 ref 是变量 var 的引用。

#include<iostream>
using namespace std;
void swap(int& a, int& b);
int main() {
	int a = 0, b = 1;
	swap(a, b);
	cout << a << " " << b << endl;
}
void swap(int& a, int& b) {
	int temp;
	temp = a;
	a = b;
	b = temp;
}

6.数组

1）一维数组

数组：所谓数组，就是一个集合，存放相同类型的数据元素

• 数组中的每个数据元素都是相同的数据类型
• 数组是由连续的内存位置组成的

一维数组定义的三种方式：

1. 数据类型 数组名[ 数组长度 ];
2. 数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};
3. 数据类型 数组名[ ] = { 值1，值2 ...};

   int score[10];
   int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
   int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
   

可用sizeof获取长度等，前面提过，不再赘述 

2）二维数组

• 二维数组定义的四种方式：

1. 数据类型 数组名[ 行数 ][ 列数 ];
2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } };
3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4};
4. 数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};

int arr[2][3];

int arr2[2][3] =
{
    {1,2,3},
    {4,5,6}
};

int arr3[2][3] = { 1,2,3,4,5,6 }; 

int arr4[][3] = { 1,2,3,4,5,6 };

7.指针 

1）定义

• 请看下方代码示例，理解指针变量的定义与使用

#include<iostream>
using namespace std;
int main(){
	int *p;//定义一个指针，他是一个int*类型的变量，*是间接引用操作符 
	int i = 5;
	p=&i;//p是一个指针。将i的地址值赋给这个指针 
	cout<<*p<<endl;//*p的意思是指向地址值存储的东西，也就是5
	cout<<p;//如果直接输出p的话，就是指针（也就是地址值）0x 
	
    return 0;
}

• 指针变量存放的是地址
• 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用（就是代码中的具体的数值！）

2）const修饰指针

const修饰指针有三种情况

1. const修饰指针 — 常量指针
2. const修饰常量 — 指针常量
3. const既修饰指针，又修饰常量

int main() {

	int a = 10;
	int b = 10;

	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int * p1 = &a; 
	p1 = &b; //正确
	//*p1 = 100;  报错
	

	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int * const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

    //const既修饰指针又修饰常量
	const int * const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	system("pause");

	return 0;
}    

• 看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量 

3）指针和数组

利用指针访问数组中元素

• C++规定，数组名就是数组的起始地址
• 数组的指针就是数组的起始地址
• 数组名可以作函数的实参和形参，传递的是数组的地址

int main() {

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

	int * p = arr;  //指向数组的指针

	cout << "第一个元素： " << arr[0] << endl; 		//1
	cout << "指针访问第一个元素： " << *p << endl;	  //1

	for (int i = 0; i < 10; i++)
	{
		//利用指针遍历数组
		cout << *p << endl;
		p++;
	}

	return 0;
}

    //省略前面代码
    vector<int> min1;
    int* px = min1.data(); // 获取指向vector数据的指针
    int* py = px + min1.size(); // 获取指向vector末尾的指针
 
   for(int*p=px; p!=py;++p) {
        cout << *p << " "; // 通过解引用指针来输出当前元素
         // 递增指针
    }
    cout << endl;

四、题目

注：基本都是我自己做完之后觉得比较符合期末考难度的题目，大家可以遮住我的代码自己写一遍哈。

1.获取三个数中的最大值（三元表达式实现）

键盘录入三个整数 a、b、c，获取这三个整数中的最大值，并输出。（要求使用三元表达式实现）

#include <iostream>
using namespace std;

int main() {
    
    int a, b, c;
    cin >> a;
    cin >> b;
    cin >> c;
    cout<<((a>b?a:b)>c?(a>b?a:b):c);
    return 0;
}

 2.判断一个数是不是质数

#include <iostream>
#include<cmath>
using namespace std;
bool is_prime(int n){
    if (n==0 || n ==1){
        return false;
    }
    else if(n==2){
        return true;
    }
    else{
        for(int i = 2;i<=sqrt(n);i++){
            if (n % i ==0){
                return false;
                }
        }
        return true;
        }
}
int main() {
    int n;
    cin>>n;
    if (is_prime(n)){
        cout<<"是质数";
    }
    else{
        cout<<"不是质数";
    }
        
    return 0;
}