全国计算机二级C++题库笔记

---

---

• 这个有几年了…
• Ⅰ. 选择题专项训练是非常全的
• Ⅱ. 套卷题目总结
  ① 基础操作题目和简单应用题没有，这个比较简单，有些填空的也不好记录，看题就行了。
  ② 应用题懒没记录了，这个考的比较简单，给你几个文件，根据题目你写一部分程序出来。主要有写链表、队列、栈、求xxx数的操作、根据题目的相关类似业务代码的那种啊（处理个字符串操作啊啥的）这种。要把前面基础打好！
• tb买个未~来~教~育~题目刷刷，下面的内容也是上面刷题遇到的然后自行整理下来的。

Ⅰ. 选择题专项训练

1 公共基础部分

2 二级C++程序设计

第1~4章

=》每章标题

• 第1章：C++基础概述
• 第2章：数据类型、运算符和表达式
• 第3章：基本控制语句
• 第4章：数组指针与引用

1. C++标识符命名规则

1. 所有标识符必须由字母、数字或下画线组成，且必须由字母或下画线开头;
2. 所有标识符不能使用C++已有的关键字;
3. 大、小写字母表示不同意义，即代表不同的标识符。

2. 面向对象的三个主要特征

1. 封装性：是指将数据和算法捆绑成一个整体，这个整体就是一个对象。
2. 继承性：是指一种事物保留了另一种事物的全部特征，并且具有自身的独有特征。
3. 多态性：是指当多种事物继承自一种事物时，同一种操作在它们之间表现出不同的形态，这是至于只属于面向对象程序设计思想的特征。

3. C++的四个开发步骤

​ 编辑 --》 编译 --》 链接 --》 运行

4. 关于类和对象的叙述

1. 类是一种类型。它封装了数据和操作
2. 对象是类的一个特定实例，创建对象的过程称之为实例化
3. 一个类可以有多个对象
4. 一个对象必须属于某个类

5. !和&&的作用

!：逻辑非运算符，它的功能是将逻辑真转换为逻辑假，或将逻辑假转换为逻辑真。对于所有非0的数值都是真，等于0的数值都是假。

&&：与运算符，注意该运算符存在短路现象。即前面第一个表达式为假时直接退出判断，后面的表达式判断是不执行的！

6. C++枚举类型初值问题

C++语言规定枚举常量的默认值依次等于0，1, … n-1，也可以给枚举常量赋初值。

如何给枚举常量赋初值：
在枚举常量的后面跟上“一个整型常量”，在给枚举常量赋初值时，如果给其中任何一一个枚举常量赋初值，则其后的枚举常量将按自然数的规则依次赋初值。

7. ASCII码对照表

8. 运算符两边的数据类型？

C/C++约定: 如果一个运算符两边的运算数的数据类型不同，先要将其转换为相同的类型，转换规则是较低类型转换为较高举型，然后再参加运算。

转换规则：(低) short/char --》 int --》 unsigned int --》 long --》 double 《-- float (高)

9. 变量的存储方式

变量的存储方法分为静态存储和动态存储两大类,包含4种：自动的(auto)、 静态的(static)、 寄存器的(register)、外部的(extern)。
变量如果没有说明存储类型，那么默认就是auto。

• extern**：可以置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。
• auto：被解释为一个自动存储变量的关键字，也就是申明一块临时的变量内存。
• register：暗示编译程序相应的变量将被频繁地使用，如果可能的话，应将其保存在CPU的寄存器中，以加快其存储速度。
• static：该变量就被定义成为一个静态变量该变量在全局数据区分配内存。

10. 计算一个正整数的各位平方和

int n = 1234;
int sum = 0;

do{
    sum += (n % 10) * (n % 10);
    n /= 10;
}while(n != 0);

11. continue、goto和break作用

continue：结束本轮循环，继续下一轮循环

goto：使程序无条件的进行转移，需要依赖标志

break：跳出循环，注意跳出的是距离break最近的一层循环

12. 3种循环

1. for循环

   // 1.基本格式
   for( (1) ; (2) ; (3) ){
       (4);
   }
   
   /*  2.步骤分析
       (1)：变量初始化语句
       (2)：条件判断语句
       (3)：循环体中具体实现功能的代码
       (4)：条件终止语句
   
   // 3.执行顺序
   	(1) -> (2) -> (4) -> (3) ----> (2) -> (4) -> (3) ---->
   	(2) -> (4) -> (3) ----> ... 直至(2)不再满足而终止循环
   */
   

2. do-while循环：至少执行一次。

   // 1.基本格式
   do{
       (1);
   }while( (2) );
   
   /*  2.步骤分析
       (1)：循环体中具体实现功能的代码
       (2)：条件判断语句
   
   // 3.执行顺序
   	(1) -> (2) ----> (1) -> (2) ----> (1) -> (2) ----> ...
   	直至(2)不再满足而终止循环
   */
   

3. while循环

   // 1.基本格式
   while( (1) ){
       (2);
   }
   
   /*  2.步骤分析
       (1)：条件判断语句
       (2)：循环体中具体实现功能的代码
       
   // 3.执行顺序
   	(1) -> (2) ----> (1) -> (2) ----> (1) -> (2) ----> ...
   	直至(2)不再满足而终止循环
   */
   

13. 引用&的叙述

1. 创建引用时不会涉及分配内存，只是起别名而已
2. 创建引用时必须立即对齐初始化
3. 引用必须与一块合法的存储空间相关联
4. 对引用的操作就是对其所引用对象的操作

第5章 函数

1. 字符串的复制

// 实现字符串赋值
void StrCopy(char *dst,char *src){
    while((*dst=*src)!='\0'){
        ++dst;
        ++src;
    }
}

2. 函数形参

1. 默认参数

   1. 通过给形参表中的形参提供明确的初始值来指定的，可以为一个或多个形参定义默认值。
   2. 如果有一个形参具有默认值，那它右边的形参都必须有默认值(即全是默认参数)，即默认参数应该从右至左逐个定义
   3. 默认形参通常在程序中第一次函数名出现的时候指定。
      1. 如果只有函数定义(在被调用函数之前定义)，则在函数定义时就需要指定默认形参。
      2. 如果出现中有函数声明，一般在函数声明中指定默认形参。
   4. 默认形参可以是一个表达式

2. 形参：函数的形参在函数被调用时获得初始值

3. 内联函数、重载函数、递归函数和嵌套函数

注：C++中函数不允许嵌套定义。

1. 内联函数

关键字：inline

在调用函数处用内联函数体的代码来进行替换，节省函数调用开销，提高函数运行的速度，内联函数的功能相对简单，且不能包含for、while、 switch语句
在类内部实现的函数默认都是内联的，不需要关键字inline。只有函数外部定义的函数才需要加inline，并且就算加了，这也是给编译器一个建议而已，编译器可以选择忽略，而并非对其内联展开，所以具体情况视编译器决定。
内联函数并非都需要return。

2. 重载函数

C++允许用同一个函数名称定义多个函数，这些函数的参数个数和参数类型不同，称为重载函数，重载函数只是有相同的函数名

特征：

• 1. 相同的范围，即在同一个类中或同一个文件中
  2. 函数名称相同
  3. 函数形参不同。注意仅当形参为引用或指针时，形参是否为const才对重载有影响
  4. virtual关键字可有可无

3. 递归函数递

归函数就是在函数体中直接或间接地调用该函数本身，递归函数使得在解决问题时容易理解，可读性较好，但在时间和空间上的开销较大，依赖栈的设计。

4. 嵌套函数

嵌套函数包含递归函数，即在调用一个函数的过程中，又去调用另一一个函数。

4. 类型转换函数

一般形式：

operator 类型名(){ /*实现转换的语句*/}

注意点：

1. 函数名前不能指定函数的类型
2. 函数没有形参

5. 运算符重载(类成员和友元！)

关于运算符重载为友元函数有如下规定:

1. 一般情况下， 单目运算符最好重载为类的成员函数，双目运算符则最好重载为类的友元函数
2. 特例双目运算符：赋值操作符=，下标操作符[]，箭头操作符->，函数调用运算符()，它们不能重载为类的友元函数，只能重载为类的成员函数
3. 非成员函数的操作符如：输入操作符>>，输出操作符<<，这两个一般定义成友元函数用来自定义输出。

6. 计算斐波那契数列

int Fib(int n){
    if(0 == n) reutrn 1;
    else if(1 == n) return 2;
    else return fib(n-1)+fib(n-2);
}

7. 十进制转二进制的递归函数

void DecToBin(unsigned int dec){
    if(0 == dec || 1 == dec)
        cout<<dec;
    else{
        dec_to_bin(dec/2);
        cout<<n%2;
    }
}

8. 遍历数组的函数

需要传入数组首地址和数组大小

void PrintArr(int arr[], int size){
    for(int i=0;i<size;++i)
        cout<<arr[i];
}

9. 判断字符串是否是回文串的递归函数

bool IsHuiWen(string str){
    int len = str.length();
    if(n <= 1)
        return true;
    if(str[0] == str[len-1])
        return IsHuiWen(str.substr(1,n-2));
    else
        return false;
}

10. 计算数列第n项

int ShuLie(int n){
    if(0 == n) reutrn 0;
    else if(1 == n) return 1;
    else if(2 == n) return 2;
    else return ShuLie(n-1)+ShuLie(n-3);
}

第6章 类和对象

1. 类成员初始化顺序

• 1. 初始化列表中的变量初始化顺序是根据成员变量声明的顺序来执行的，与初始化列表中的顺序无关
  2. 如果有成员对象，则先初始化成员对象，多个成员对象就按照对象的声明顺序去初始化

2. extern的作用

用于声明函数或全局变量的作用范围的关键字，其声明的函数和变量可以在本模块活其他模块中使用，它是一个声明不是定义。表示该变量或者函数已经在其他文件中定义过，在本文件或者模块中声明一下就可以使用。

3. 常成员函数的格式

返回值类型 函数名() const

4. 运算符重载(类成员和友元！)

关于运算符重载为友元函数有如下规定:

1. 一般情况下， 单目运算符最好重载为类的成员函数，双目运算符则最好重载为类的友元函数
2. 特例双目运算符：赋值操作符=，下标操作符[]，箭头操作符->，函数调用运算符()，它们不能重载为类的友元函数，只能重载为类的成员函数
3. 非成员函数的操作符如：输入操作符>>，输出操作符<<，这两个一般定义成友元函数用来自定义输出。

5. 友元函数

友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息(包括私有成员和保护成员)，友元函数必须在类中声明。

• 友元关系三条规则:
  1. 友元关系不能被继承。
  2. 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
  3. 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不定是类A的友元，同样要看类中是否有相应的申明

6. 隐式的this指针

类中谁含有this指针？
只有类的非静态成员函数才隐含this指针，其作用域是类内部，当类的非静态成员函数中访问类的非静态成员时，编译器会自动将对象本身的地址作为一个隐含参数传递给函数，而不必一定写上this。

为什么静态成员没有this指针？
在C++中，静态成员是类的组成部分，不是任何对象的组成部分，所以静态成员是没有this指针的。

7. 静态成员初始化

静态数据成员只能在类体外进行初始化，其一般形式为：类型名::静态数据成员名 = 初值;

8. 成员函数的特性描述

1. 类的成员函数描述的是类的行为，是程序算法的实现部分，是对封装的数据进行操作的方法。
2. 类的成员函数的原型要写在类体中，原型说明了函数的参数表和返回值类型。而函数的定义一般在类外面，也可以直接在类內部定义。前者与普通函数不同的是，实现成员函数时要指明类的名称。
3. 类的成员函数，也是普通的函数，可以递归、重载、设置默认参数值。
4. 内联函数是指用inline关键字修饰的函数。在类内定义的函数被默认成内联函数。当在成员函数的原型写在类内，而在类外定义时，它是成员函数却不是内联函数。

9. 拷贝(复制)构造函数被调用情况

三种情况:

1. 当用一个对象去初始化同类的另一个对象时,会引发复制构造函数被
   调用。
2. 如果函数F的参数是类A的对象，那么当F被调用时，类A的复制构造函数将被调用。
3. 如果函数的返回值是类A的对象，则函数返回时，类A的复制构造函数被调用。系统默认的复制构造函数实现的时一种浅层复制，要想实现深层复制如数组的拷贝，只能自定义复制构造函数。

10. 析构函数

1. 析构函数(destructor) 与构造函数相反，当对象脱离其作用域时(例如对象所在的函数已调用完毕)，系统自动执行析构函数。
2. 析构函数往往用来做清理善后的工作(例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放)。
3. 以C++语言为例，析构函数名也应与类名相同，只是在函数名前面加一个波浪符，以区别于构造函数。
4. 析构函数不能带任何参数，也没有返回值(包括void类型)。
5. 一个类只能有一个析构函数，不能重载。
6. 如果用户没有编写析构函数，编译系统会自动生成一个缺省的析构函数，它也不进行任何操作。

11. 常对象和成员对象

常对象：
是指对象的数据成员不能被修改。常对象必须在定义的同时进行初始化，且不能改变，需要使用初始化列表来进行初始化。不能通过常对象去调用非const型的普通成员函数。

成员对象： 当一个类中的数据成员是另一个类的对象时，此时这个对象就称之为成员对象(对象成员)。

12. 初始化列表(:{ })的作用！！！

1. 用来初始化类的数据成员

2. 用来初始化类中的常数据成员

3. 用来初始化类中的成员对象，成员对象初始化的顺序是它们在类中声明的顺序

   • 初始化成员对象分为两种情况：

     (1) 该对象具有[无参的构造函数]或[默认生成的构造函数]，这时使用初始化列表，有可能提升性能。

     (2) 该对象只有[有参数的构造函数]，此时必须使用初始化列表对成员对象进行初始化。

第7章 继承与派生

1. public继承、protected继承和private继承

1. 公有继承：基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态，基类的私有成员仍然是私有的，不能被这个派生类的子类所访问;
2. 保护继承：基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。
3. 不能在类外以任何方式访问类当中的私有和保护的成员变量和成员函数。除非是在友元类或者友元函数当中。·

2. 设置虚基类的目的

目的：消除二义性
原因：
多重继承的派生类有可能从两个或多个基类中继承同名成员，对该成员不加限定的访问就会造成二义性，虚基类就是为了解决这个二义性问题，无论该类在派生层次中作为虚基类出现多少次，都只继承一个共享的基类子对象，从而消除二义性。

3. 抽象类的叙述

1. 含有一个或多个纯虚函数的类是抽象类，作为抽象类的派生类的对象的组成部分，不能创建抽象类的
   对象
2. 由于无法创建(也不需要创建)抽象类的对象，所以抽象类的构造函数可以是protected函数
3. 抽象类的派生类，如果也包含纯虚函数，那么该派生类也是抽象类

4. 虚继承的叙述

1. 虚继承中，无论虚基类出现在继承层次中的任何地方，总是在构造非虚基类之前构造虚基类，并且构造函数的调用仍然是按照继承的顺序执行的。
2. 若同一层中包含多个虚基类，这些虚基类的构造函数按照它们声明的次序调用

第8章 运算符重载

1. 重载运算符的规则！！！

• 1. C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载;

  2. C++不能重载的运算符只有5个，如下：

     • 三目运算符：?:
     • 成员访问运算符：.
     • 作用域运算符：::
     • 内存大小操作符：sizeof
     • 成员指针访问运算符：.*

  3. 重载不能改变运算符的运算对象个数、优先级和结合性;

  4. 重载运算符的函数不能有默认的参数;

  5. 重载的运算符必须和用户定义的自定义类型的对象一起使用，至少应有一个是类对象，即不允许参数全部是C++的标准类型。

     ---

  6. 一般情况下，单目运算符最好重载为类的成员函数，双目运算符则最好重载为类的友元函数;

  7. 双目运算符=，()，[]，->不能重载为类的友元函数，只能重载为类成员函数;

  8. 类型转换函数只能定义为一个类的成员函数，而不能定义为类的友元函数;

  9. 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好;

  10. 若运算符所需的操作数(尤其是第一个操作数)希望有隐式类型转换，则只能选用友元函数;

  11. 当运算符函数是一个成员函数时，最左边的操作数(或者只有最左边的操作数必须是运算符类的一个类对象(或者是对该类对象的引用);如果左边的操作数必须是一个不同类的对象，或者是一个内部类型的对象，该运算符函数必须作为一个友元函数来实现。

2. 运算符重载的两种形式！！！

• 重载为类的成员函数

  当运算符重载为类的成员函数时,函数的参数个数比原来的操作数要少一个(后置单目运算符除外)，这是因为成员函数用this指针隐式地访问了类的一个对象，它充当了运算符函数最左边的操作数。
  因此:
  (1)双目运算符重载为类的成员函数时，函数只显式说明一个参数，该形参是运算符的右操作数。
  (2)前置单目运算符重载为类的成员函数时，不需要显式说明参数，即函数没有形参。
  (3)后置单目运算符重载为类的成员函数时，函数要带有一个整型形参。

• 重载为类的友元函数

  当运算符重载为类的友元函数时，由于没有隐含的this指针，因此操作数的个数没有变化，所有的操作数都必须通过函数的形参进行传递，函数的参数与操作数自左至右一一对应。
  输入操作符>>，输出操作符<<，这两个一般定义成友元函数用来自定义输出。

3. 类型转换函数

类型转换函数，其一般形式如下:

operator 类型名() { /*实现转换的语句*/ }

注：类型转换函数不需要声明返回值类型。

第9章 模板(泛型编程)

模板的类型参数由关键字class或关键字typename及其后的标识符构成，(在标准C++之前关键字typename没有被支持，把这个关键字加入到C++中的原因是因为有时必须要靠它来指导编译器解释模板定义。

第一种：函数模板

函数模板针对仅参数类型不同的函数。

1. 函数模板定义形式

// 1.文字版本
template <typename/class 模板形参> 
返回值 函数名 (形参表)
{
    //语句序列
}

// 2.具体版本
template <typename T, typename T2, ... > 
T 函数名 (T a,T b, ...)
{
    //语句序列
}

/* 参数说明：
T：模板形参

模板实参表：用<>括起来的参数表

模板函数实参表：用()括起来的参数表
*/

2. 模板函数实参省略条件！！！

模板函数的实参可以省略，但模板实参的省略并不是必然的，而是有条件的。

在调用一个模板函数时，编译系统需要足够的信息来判别每个虚拟类型参数所对应的实际类型，可以从两个不同的渠道获得这样的信息：
（1）从模板实参表(<>中的参数表)获取；
（2）从模板函数实参表(()中的参数表)获取；
模板实参的信息优先于模板函数实参的信息。

**如果从模板函数实参获得的信息已经能够判定其中部分或全部虚拟类型参数所对应的实际参数，而且它们又正好是参数表中最后的若干个参数，**则模板实参表(<>中的参数表)中的那几个参数可以省略。如果模板实参表中的实参都被省略了，则连空表<>也可以不要。

反之，对于某个模板实参，如果从模板函数的实参表(()中的参数表)中无法获得同样的信息，就不能省略;或者虽然能够获得同样的信息，但在它后面还有其他不能省略的实参，则其自身还是不能省略。

3. 区分函数模板和模板函数

函数模板：是一系列相关函数的模型或样板，这些函数的源代码形式相同，只是针对的数据类型不同，其并不是函数重载;
模板函数：函数模板中声明的函数称为模板函数，模板函数是函数模板的一个实例。编译系统生成函数模板的某个具体版本的过程称为函数模板的实例化，其过程是不仅可见的;

4. 函数模板形参列表的分为两种

1. 类型形参：即不确定具体的类型，根据实例化时指定的类型进行自动推导;
2. 非类型形参：可以指定一个具体的类型，如整型(int)、指针(*)、引用类型(&)，实例化时要求对应位置的参数类型与模板中非类型形参保持一致，否则无法推导进行实例化。

第二种：类模板

类模板针对仅数据成员和成员函数类型不同的类。

注意点：

1. 类模板的成员函数都是模板函数

第10章 C++流

四个标准输出流对象：cin，cout，cerr，clog

1. <<和>>运算符的重载！！！

(1) C++标准类型的数据：

C++的流插入运算符(<<)和流提取运算符(>>)是C++在类库中提供的，所有C++编译系统都在类库中提供输入流类(istream)和输出流类(ostream)。cin和cout分别是istream类和ostream类的对象。
在类库提供的头文件中已经对<<和>>进行了重载，使之作为流插入运算符和流提取运算符，能用来输出和输入C++标准类型的数据。因此，凡是用cout<<和cin>>对标准类型数据进行输入输出的，都需要使用#include<iostream>语句把它们头文件包含到本程序文件中。

(2) 用户自定义类型的数据：

用户自定义的类型的数据，是不能直接用<<和>>来输出和输入的。如果想用它们输出和输入自己声明的类型的数据，则必须对它们重载。对<<和>>重载的函数形式如下:

// 第一个参数和函数的类型都必须是[istream&]类型，第二个参数是要进行[输入操作的类](自定义类&)。
istream & operator >> (istream &, 自定义类&);

// 第一个参数和函数的类型都必须是[ostream&]类型，第二个参数是要进行[输出操作的类](自定义类&)。
ostream & operator << (ostream &, 自定义类&);

注意：只能将重载**>>和<<**的函数作为友元函数或普通的函数，而不能将它们定义为成员函数。

2. 提取操作和插入操作

提取操作：从流中获取数据的操作

插入操作：向流中添加数据的操作

3. 格式化输出

需要包含头文件：#include <iomanip>

3.1 使用cout进行输出

(1) 便捷的控制符

使用iostream工具来设置一下格式值(如字段宽度)不太方便。为简化工作，在C++头文件iomanip中提高了其他的一些控制符。

序号	便捷控制符	作用
1	setprecision(n)	设置小数精度
2	serfill(n)	设置填充字符，结合宽度控制(setw(n))使用
3	setw(n)	设置字段宽度，作用于紧接着输入的字符串，且只对一次输出有效
…

(2) 一些标志控制符

序号	标准控制符	作用
1	(1) boolalpha (2) noboolalpha
2	(1) showbase (2) noshowbase
3	(1) showpoint (2) noshowpoint	(1) 设置显示小数点 (2) 设置不显示小数点
4	(1) showpos (2) noshowpos	(1) 设置输出正数时显示+号 (2) 设置输出正数时不显示+号
5	(1) uppercase (2) nouppercase	(1) 设置大写输出 (2) 设置不大写输出
6	internal
7	left	设置左对齐，结合宽度控制使用(setw(n))使用
8	right	设置右对齐，结合宽度控制使用(setw(n))使用
9	dec	设置整数为十进制
10	hex	设置整数为十六进制
11	oct	设置整数为八进制
12	fixed	设置浮点数以固定的小数位显示
13	scientific	设置浮点数以科学记数法显示

3.2 使用cin进行输入

cin用来接收字符串时，遇到空格，TAB，回车时都会结束。

4. 文件定位符

(1) ios_base::cur：文件当前位置

(2) ios_base::beg：文件开始位置

(3) ios_base::end：文件尾部位置

5. 文件模式

常量	含义
ios::in	打开文件，以便读取
ios::out	打开文件，以便写入
ios::app	打开文件，追加到文件末尾
ios::trunc	如果文件存在，则以截断的方式写文件
ios::ate	打开文件，并移到文件末尾
ios::binary	以二进制方式进行读写

6. getline函数(输入流成员函数)

函数原型：getline(istream &is, string &st)

作用：将输入流is中读到的字符存入str中，直到遇到换行符('\n')才结束。

参数解释：第一个参数is是输入流对象， 这个对象可以是键盘输入流对象，也可以是文件输入流等其他输入流的对象。

函数原型：istream& getline(istream &is，string &str，char delim);

作用：将输入流is中读到的字符存入str中，直到遇到终结符delim才结束。

参数解释：参数delim可以由用户自己定义的终结符

读取原理：函数在输入流is中遇到文件结束符(EOF) 或者在读入字符的过程中遇到错误都会结束。在遇到终结符delim后，delim会被丢弃，不存入str中。在下次读入操作时，将在delim的下个字符开始读入。

Ⅱ. 套卷题目总结

1. 选择题

1. 各种排序比较次数

排序方法	最好比较次数	最坏比较次数
堆排序		$$nlog2n$$
快速排序		$$\frac{n(n-1)}{2}$$
顺序查找		$$n$$,寻找最大项为 $$n-1$$
二分查找		$${\log }_{2}n$$

2. 树的总结点计算

树的总结点数 = 树中所有结点的度数之和 + 1

叶子节点：度为0的结点

3. 计算扇入数

扇入：调用一个给定模块的模块个数。

最大扇入数：一个给定的模块被其他几个不同的模块所调用。

4. 软件测试实施步骤

软件测试的实施过程主要有4个步骤：

1. 单元测试
2. 集成测试
3. 确认测试(验收测试)
4. 系统测试

5. 关系数据库基本特征

关系数据库中的二维表一般满足7个基本特征:

1. 元组(行)个数是有限的 —> 元组个数有限性
2. 元组(行)均不相同 —> 元组的唯一性
3. 元组(行)的次序可以任意交换 —> 元组的次序无关性
4. 元组(行)的分量是不可分割的基本特征 —> 元组分量的原子性
5. 属性(列)名各不相同 —> 属性名唯一性
6. 属性(列)与次序无关，可以任意交换 —> 属性的次序无关性
7. 属性(列)的分具有与该属性相同的值域 —> 分量值域的统一性

6. 虚函数叙述

1. 虚基类中并不是所有函数都是虚函数，因此从虚基类继承的函数不一定为虚函数;
2. 虚函数除了通过指针和引用调用外，还可以通过对象访问虚函数;
3. 抽象类中的成员函数不一定都是虚函数，只要类中含有纯虚函数，该类就是抽象类，注意抽象类不可以进行实例化；
4. 虚函数不得是静态成员函数

7. 完全二叉树结点计算

完全二叉树是指除最后一层外，每一层上的节点数均达到最大值，在最后一层上只缺少右边的若干结点。
例如：深度为4的满二叉树的结点数为2*-1=15，深度为5的满二叉树的结点数为2-1=31,所以深度为5的完全二叉树的结点数应大于15且小于等于31。

8. 软件过程

1. 软件过程是把输入转化为输出的一组彼此相关的资源和活动。
2. 软件过程是将软件工程的方法和工具综合起来，以达到合理、及时地进行计算机软件开发的目的。
3. 软件过程应确定方法使用的顺序、要求交付的文档资料、为保证质量和适应变化所需要的管理、软件开发各个阶段完成的任务。

9. 内聚和耦合

耦合：用于衡量不同模块彼此间互相依赖(连接)的紧密程度;

内聚：用于衡量一个模块内部各个元素彼此结合的紧密程度。

模块独立性的高低是设计好坏的关键，而设计又是决定软件质量的关键环节，好的软件的模块独立性性要好,即高内聚低耦合。

10. 寻址方式

**寻址方式： **是指找到当前正在执行指令的数据地址以及下一条将要执行指令的地址的方法。

寻找方式两大分类：

• 指令寻址
  • (1) 顺序寻址
  • (2) 跳跃寻址
• 数据寻址
  • (1) 立即寻址 : 所需的操作数由指令的地址码部分直接给出
  • (2) 直接寻址 : 指令的地址码部分给出操作数在存储器中的地址
  • (3) 隐含寻址 : 操作数的地址隐含在指令的操作码或者某个寄存器中
  • (4) 间接寻址 :
  • (5) 寄存器寻址 :
  • (6) 寄存器间接寻址 :
  • (7) 基址寻址 :
  • (8) 变址寻址 :
  • (9) 相对寻址 :
  • (10) 堆栈寻址 :

11. 数据库范式判断

第一范式(1NF): 主属性(主键)不为空且不重复，字段不可再分(存在非主属性对主属性的部分依赖)。

第二范式(2NF): 如果关系模式是第一范式， 每个非主属性都没有对主键的部分依赖。

第三范式(3NF): 如果关系模式是第二范式，没有非主属性对主键的传递依赖。

BCNF范式: 所有属性都不传递依赖于关系的任何候选键。

12. 有序表

1. 有序表是指表中的元素按照某种规则已经排好了位置

2. 有序表既可以采用顺序存储结构存储在连续的存储空间内,也可以采用链式存储结构存储在不连续的存储空间内

3. 能使用二分法查找的线性表必须满足两个条件: (1)用顺序存储结构; (2)线性表是有序表

4. 有两个指针域的链表也可能是双向链表

5. 循环链表是链式存储结构,循环队列是队列的一种顺序存储结构

6. 带链的栈属于线性单链表

7. 结点中具有多个指针域的链表就称为多重链表

13. 二叉树结点计算

1. 对任何一棵二叉树，度为0的结点(即叶子结点)总是比度为2的结点多一个。
2. 在完全叉树中，只在最后一层上缺少右边的若干结点，所以度为1的结点个数为0或1。

假设度为2的结点个数为x，则叶子结点个数为x+1.若度为1的结点个数为0, x+x+1+0无法和2n相等,不存在这样的二叉树，则度为1的结点个数为1, x+x+1+1=2n, x=n-1, 所以叶子结点个数为n。

2. 基础操作题目(略)

3. 简单应用题(略)

4. 综合应用题

4.1 求完全数

完全数(完美数/完备数)： 它所有的真因子(除自身以外的约数)的和(即因子函数)，恰好等于它本身。即一个数恰好等于它的真因子之和，则称该数为完全数。

void PerfectInteger(int min, int max){
    int sum = 0;
    for(int i = min; i <= max; i++) {
        sum = 0;
        for (int j = 1; j < i; j++) {
            if (i % j == 0)
                sum += j;
        }
        if (sum == i)
            cout << i << " 是完全数" << endl;
    }
}

4.2 求回文数

回文数： 反向排列与原来一样的数就叫做回文数。

实现代码：

方法一：直接求逆序!!!

void Palindrome(int min, int max) {
	int p = 0;
	for (int i = min; i <= max; i++)  {
		int num = i;
		p = 0;
		while (num>0) {
			p = p * 10 + num % 10; 
			num /= 10;
		}
		if (p == i)
			cout << i << " 是回文数" << endl;
	}
}

方法二：求位数，再对称判断

void Palindrome(int min, int max) {
	int p = 0;
	for (int i = min; i <= max; i++) {
		int weishu = 1;
		int temp = i;
        // 1.求位数
		for (; temp / 10 == 0;) 
            weishu++;
        // 2.判断是否对称相等
		for(temp = i; weishu > 0; weishu--){
			if (temp % 10 == temp / (weishu * 10)) 
				temp /= 10;
			else
				break;
		}
        // 3.最终回文数判断
		if (weishu == 0)
			p = i;
		if (p == i)
			cout << i << " 是回文数" << endl;
	}
}

4.3 求花朵数

花朵数： 一个n位的十进制正整数，它的每个位上的数字的n次方的和等于这个数本身

void FlowerNumber::Flower() {
	int sum = 0;
	for (int i = min; i <= max; i++) {
		int weishu = GetDigits(i);
		int temp = i, ret;
		while (temp) {
			ret = 0;
			if ((temp % 10) != 0) {
				ret = 1;
				for (int j = 0; j < weishu; j++) 
					ret *= (temp % 10);
			}
			sum += ret;
			temp /= 10;
		}

		if (sum == i)
			cout << i << " 是花朵数" << endl;
		sum = 0;
	}
}

---

end.