【计挑赛】程序设计类真题（C++）

最新推荐文章于 2025-10-26 23:41:36 发布

SpareLin

最新推荐文章于 2025-10-26 23:41:36 发布

阅读量563

点赞数 11

CC 4.0 BY-SA版权

文章标签： c++ java jvm

本文链接：https://blog.csdn.net/weixin_55664293/article/details/153875172

文章目录

2024
2022

2024

客观题

C++ 中 typedef 和 #define 的区别是什么？
A. typedef用于定义常量，#define用于定义类型
B. typedef是编译时的类型定义，#define是预处理指令
C. typedef只能用于指针，#define用于定义宏
D. typedef不能定义指针类型，#define可以
在C++语言中，int fun() 和 int fun(void) 有什么区别？
A. int fun() 和 int fun(void) 完全相同，都是不带参数的函数声明
B. int fun() 是有参数的函数声明，而 int fun(void) 是无参数的函数声明
C. int fun() 表示函数可以接受任意数量的参数，而 int fun(void) 表示函数不接受任何参数
D. int fun() 是C语言的语法，int fun(void) 是C++特有的语法
若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用哪种数据结构最合适？
A. 数组
B. 链表
C. 栈
D. 队列
在C++中，如何阻止一个类被实例化？
A. 将类的构造函数声明为protected
B. 将类的构造函数声明为private
C. 将类声明为abstract类
D. 将类声明为final类

A. 将类的构造函数声明为 protected
不完全正确。如果构造函数是 protected，外部不能直接实例化，但派生类可以调用构造函数，因此该类仍可通过派生类间接“实例化”（派生类对象包含基类部分）。
C. C++ 中没有 abstract 关键字，抽象类是通过包含纯虚函数实现的。但抽象类虽然不能直接实例化，可以定义指针/引用，并且可以实例化其派生类（如果派生类实现了纯虚函数）。
D. 将类声明为 final 类
错误。final 关键字是禁止类被继承，但不影响其实例化。

关于类的静态成员和非静态成员，以下说法错误的是？
A. 静态成员在内存中只有一份，而每个对象都有自己独立的非静态成员。
B. 静态成员可以在类的外部直接访问，而非静态成员只能通过对象访问。
C. 静态成员不能在构造函数和析构函数中被访问。
D. 非静态成员函数可以调用静态成员函数，但静态成员函数不能调用非静态成员函数。
在单链表中，若要删除指针为 p 的结点（假设 p 是要删除的结点），正确的操作是？
A. p = p->next; delete p;
B. p->next = p->next->next;
C. delete p->next; p = nullptr;
D. q->next = p->next; delete p; (其中 q 是 p 的前驱结点)
数组 B 中，每个元素的长度为 4 个字节，行下标 I 从 0 到 6，列下标 J 从 0 到 9，从首地址 SB 开始连续存放在存储器内。该数组按行存放时，元素 B[6][3] 的起始地址为 ( )？
A. SB + (6 * 10 + 3) * 4
B. SB + (6 * 9 + 3) * 4
C. SB + (6 * 10 + 3) * 3
D. SB + (6 * 4 + 3) * 10
设 a = 12，b = 3，c = 5，则以下表达式 $\bmod b == 0$ && $c * c > a + b * * b$ 的结果是？
A. True
B. False
C. 1
D. 0
在64位系统上有以下代码：
const char *message = "C++ Programming!";
则sizeof(message)和strlen(message)的结果分别是( )。
A. sizeof(message) = 4, strlen(message) = 17
B. sizeof(message) = 8, strlen(message) = 16
C. sizeof(message) = 8, strlen(message) = 15
D. sizeof(message) = 16, strlen(message) = 15
若一棵二叉树具有 8 个度为 2 的结点，6 个度为 1 的结点，则度为 0 的结点的个数是 ( )？
A. 7 B. 8 C. 9 D. 10
以下代码的输出是什么？

#include <iostream>
using namespace std;
int main() {
    int a = 5;
    int* p = &a;
    *p += 5;
    cout << a << endl;
    return 0;
}

A. 编译错误
B. 5
C. 10
D. 15

以下代码的输出是什么？

#include <iostream>
using namespace std;
class A {
public:
    A() { cout << "A's constructor" << endl; }
    ~A() { cout << "A's destructor" << endl; }
};
class B {
public:
    B() { cout << "B's constructor" << endl; }
    ~B() { cout << "B's destructor" << endl; }
};
int main() {
    A a;
    B b;
    return 0;
}

A's constructor
B's constructor
A's destructor
B's destructor

A's constructor
B's constructor
B's destructor
A's destructor

B's constructor
A's constructor
B's destructor
A's destructor

D. 编译错误

下面的代码段展示了 C++ 模板的用法。请问关于 add 函数的哪项说法是正确的？

template <typename T>
T add(T a, T b) {
    return a + b;
}
int main() {
    cout << add(5, 10) << endl;
    cout << add(5.5, 4.5) << endl;
    return 0;
}

A. add 函数只能接受整数类型的参数
B. add 函数会在执行时决定返回类型
C. add 函数无法处理不同类型的参数
D. 该代码会导致编译错误

补全updateValue函数，使得输出结果为30。

#include <iostream>
using namespace std;
void updateValue(int* ptr) {
    // 补全代码
}
int main() {
    int a = 20;
    updateValue(&a);
    cout << a << endl;
    return 0;
}

A. ptr = 10;
B. *ptr = 10;
C. ptr++;
D. ptr += 10

现有一个大根堆，堆中元素为 [30, 20, 15, 10, 8, 12]。若要向堆中插入元素 25，插入后堆中元素变化如何？
A. [30, 25, 15, 20, 8, 12, 10]
B. [30, 20, 25, 10, 8, 12, 15]
C. [30, 20, 15, 25, 8, 12, 10]
D. [30, 20, 15, 10, 25, 12, 8]

编程题

1. 农作物丰收竞赛（贪心）

在一个农业大国，每年都会举行一次盛大的农作物丰收竞赛，农民们将自己种植的庄稼进行收割，并按照产量排名，争夺丰收冠军的称号。参赛的农民需要连续数天展示自己的农作物产量，最终以累积的总产量决定最终的胜利者。
今年的丰收竞赛进入了最后一天，前几天的比赛中，农民们已经累积了各自的收成。然而，最后一天的产量将会是决定性的，因为当天的产量将以特别规则计算得分：当天的第一名农民将获得 N 点得分，第二名将获得 N-1 点得分，依次类推，最后一名将获得 1 点得分。最后一天的得分，没有并列的情况出现。
现给定当前每位农民的累积得分，计算在最后一天比赛开始前，有多少位农民仍然有可能通过最后一天的比赛获得最终的丰收冠军（最终总冠军有可能存在并列）。

输入格式

第一行输入一个整数 N，表示参赛农民的总数。
接下来的 N 行分别输入N位农民当前的累积得分。

输出格式

输出一个整数，表示有多少位农民仍然有可能获得最终的丰收冠军。

输入样例1

输出样例1

输入样例2：

输出样例2：

$C o d e$

#include <bits/stdc++.h>

using namespace std;

const int N = 3e5 + 7;

int a[N], n;

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    sort(a + 1, a + n + 1, greater<int>());
    
    int maxv = -1;
    for (int i = 1; i <= n; i++) {
        maxv = max(maxv, a[i] + i); // 贪心 最大值最小化
    }
    
    int res = 0;
    for (int i = 1; i <= n; i++) {
        if (a[i] + n >= maxv)
            res ++;
    }
    cout << res << endl;
    return 0;
}

2. 修复公路（贪心）

在一个风景如画的国家，著名的“黄金大道”连接着各个旅游景点。然而，随着游客数量的激增，这条大道出现了许多破损路段，影响了游客的行程。为了确保游客的安全和顺利通行，国家决定对这些破损路段进行修复，并在某些路段实施临时封闭。你作为负责交通管理的工程师，需要计算出最少需要封闭的路段总长度，以便尽快修复这些问题区域。
现给定 n 个破损路段的坐标和需要实施封闭的路段数量 m，要求找到一种分配方案，使得封闭的路段总长度最小。

输入格式

第一行包含两个正整数 n 和 m（中间使用一个空格符隔开，m后不许有空格）。
第二行包含 n 个整数，表示破损路段的坐标（坐标值为长整型，且按从小到大的顺序给出，且不会有两个点坐标相同）（n个整数之间使用一个空格符隔开，最后一个整数后不许有空格）。

输出格式

输出一个整数，表示最小的封闭路段总长度。

输入样例1

18 4
3 4 6 8 14 15 16 17 21 25 26 27 30 31 40 41 42 43

输出样例1

说明

封闭的路段为：3-8、14-21、25-31、40-43，最小的封闭路段总长度为6+8+7+4=25。
提示：路段3-8的封闭情况如下图所示。
在这里插入图片描述

输入样例2：

8 4
2 5 6 7 11 12 15 20

输出样例2：

$C o d e$

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
const int N = 3e5 + 7;

LL n, m;
LL a[N], b[N];

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    
    vector<LL> v;
    for (int i = 2; i <= n; i++) { // 共 n - 1段
        v.push_back(a[i] - a[i - 1] - 1);
    }

    sort(v.begin(), v.end(), greater<int>());
    // 选择 m - 1 个最大的间隔（好路长度）断开
    // [a, b]封闭路段长度为 b - a + 1
    LL res = a[n] - a[1] + 1;
    for (int i = 0; i < m - 1; i++) { 
        res -= v[i];
    }
    cout << res << endl;
    return 0;
}

3. 限时抢购（二进制拆分背包）

小明来到了超市，正在进行限时抢购活动。在这次活动中，他可以在限定时间内尽可能多地把自己喜欢的商品放进购物车，而不需要花费一分钱。购物车的最大承重为 W，他希望在不超载的情况下，尽可能获取价值最大的商品。
超市中有 n 种商品，每种商品的价值为 $v_i$ ，重量为 $w_i$ ，每种商品的数量为 $m_i$ 。小明的目标是选择一些商品，使购物车的总重量不超过 $W$ ，同时获取的商品总价值最大。

输入格式

第一行包含两个整数 n 和 W，分别表示商品种类的数量和购物车的最大承重（ $n$ 和 $W$ 中间使用一个空格隔开）
接下来的 n行，每行包含三个整数 $v_i、w_i、m_i$ ，分别表示第 i 种商品的价值、重量和数量（每一行的 $v_i、w_i、m_i$ 中间使用一个空格隔开， $m_i$ 后不可有空格）。

输出格式

输出一个整数，表示在不超载的情况下，小明能够获取的最大商品总价值。

输入样例1

输出样例1

输入样例2：

输出样例2：

$C o d e$

#include<bits/stdc++.h>

using namespace std;

int n, m, a[505], b[505], c[505], dp[60001];

void pidan(int p, int q) { // 01背包
    for (int j = m; j >= p; j--) {
        dp[j] = max(dp[j], dp[j - p] + q);
    }
    return;
}

void nadip(int p, int q) { // 完全背包
    for (int j = p; j <= m; j++) {
        dp[j] = max(dp[j], dp[j - p] + q);
    }
    return;
}

void multiplepack(int mon, int p, int num) {
    if (mon * num >= m) {
        nadip(mon, p);
    } else { // 二进制拆分
        int k = 1;
        while (k <= num) {
            pidan(k * mon, k * p);
            num -= k;
            k *= 2;
        }
        pidan(num * mon, num * p);
    }
    return;
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) 
        cin >> a[i] >> b[i] >> c[i]; // 输入
    
    for (int i = 1; i <= n; i++) {
        multiplepack(b[i], a[i], c[i]); // 多重背包
    }

    cout << dp[m]; // 输出
    return 0;
}

4. 关闭魔法阵（DFS/区间DP）

在一个古老的魔法学院中，有一条长廊布满了魔法阵，每个魔法阵持续释放能量。魔法师小明受命关闭这些魔法阵，以防止能量泄漏造成危险。
这条长廊上总共有 n 个魔法阵，魔法阵的位置已经固定（每个位置是一个整数，代表距离长廊起点的距离）。每个魔法阵有不同的能量消耗，持续运行时会释放不同的能量。小明站在其中一个魔法阵旁，他的任务是尽量快地关闭所有魔法阵，减少能量的浪费。
小明可以从当前的位置出发，选择向左或向右去关闭魔法阵。每关闭一个魔法阵，魔法阵就不再释放能量。小明走动的速度为1米每秒，走动的时间越长，未关闭的魔法阵就释放更多的能量。因此，小明希望找到一种最优的关闭顺序，使得总的能量损耗最小。（小明关闭每个魔法阵的时间很短，可以忽略不计）

输入格式

第一行包含两个整数 n 和 c，分别表示魔法阵的总数 n 和小明当前所处的魔法阵编号 c（编号从 1 开始）（n和c中间使用一个空格隔开，c之后不准有空格）。
接下来 n 行，每行包含两个整数，分别表示第 i 个魔法阵的位置（单位：米）和该魔法阵的能量消耗速率（单位：能量每秒）。所有位置是单调递增的。（每行的两个整数之间使用一个空格隔开，每行的最后一个整数后面不可有空格）

输出格式

输出一个整数，表示最小的总能量损耗。

输入样例1

输入出样例1

说明

此时关闭顺序为 3、4、2、1、5：

从位置 5（第 3 个魔法阵）走到位置 6（第 4 个魔法阵），消耗时间 1 秒，产生能量损耗为 30 × 1 = 30
从位置 6 返回到位置 3（第 2 个魔法阵），消耗时间 3 +1=4秒，产生能量损耗为 20 × 4 = 80
从位置 3 返回到位置 2（第 1 个魔法阵），消耗时间 1+3+1=5 秒，产生能量损耗为 10 × 5 = 50
从位置 2 最后走到位置 8（第 5 个魔法阵），消耗时间 6+1+3+1=11 秒，产生能量损耗为 10 ×11 = 110
总能量损耗为 30 + 80 + 50 + 110 = 270。

输入样例2：

输出样例2：

$C o d e$

#include<bits/stdc++.h>
using namespace std;

struct abc {
    int p;
    int place;
};

int ans = 9999999, may, n, pl, all;
abc s[55];
bool z[55];

bool cmp(abc a, abc b) {
    return a.place < b.place;
}

void search(int now) {
    bool is = false;
    if (may > ans) return;

    int i = now;
    while (z[i] && i < n) i++;
    if (!z[i]) {
        z[i] = true;
        may += all * (s[i].place - s[now].place);
        all -= s[i].p;
        search(i);
        all += s[i].p;
        may -= all * (s[i].place - s[now].place);
        z[i] = false;
        is = true;
        i = now;
    }
    
    while (z[i] && i > 1) i--;
    if (!z[i]) {
        z[i] = true;
        may += all * (s[now].place - s[i].place);
        all -= s[i].p;
        search(i);
        all += s[i].p;
        may -= all * (s[now].place - s[i].place);
        z[i] = false;
        is = true;
        i = now;
    }
    
    if (!is && ans > may) ans = may;
}

int main() {
    int i;
    bool can = false;
    
    scanf("%d%d", &n, &pl);
    memset(z, 0, sizeof(z));
    
    for (i = 1; i <= n; i++) {
        scanf("%d%d", &s[i].place, &s[i].p);
        all += s[i].p;
        
        if (i == pl && !can) {
            pl = s[i].place;
            all -= s[i].p;
            z[i] = true;
            can = true;
        }
    }
    
    sort(s + 1, s + n + 1, cmp);
    
    for (i = 1; i <= n; i++) {
        if (pl == s[i].place) {
            pl = i;
            break;
        }
    }
    
    search(pl);
    printf("%d", ans);
    return 0;
}

2022

客观题

1.以下说法中正确的是（）。

A. 基类的私有成员在派生类的对象中不可访问，也不占内存空间
B. 封装性指的是将不同类型的相关数据组合在一起，作为一个整体进行处理
C. 在面向对象的程序设计中，结构化程序设计方法仍有着重要作用
D. 多态性指的是对象的状态会根据运行时要求自动变化

2.执行以下程序后，输出的结果是（）。

#include<iostream>
using namespace std;
int main() {
    int a=4,b=5;
    float c=b/a;
    cout<<c<<endl;
    return 0;
}

A. 1.25
B. 0
C. 1.3
D. 1

3.以下描述不正确的是（）。

A. break语句在一层循环体中可出现多次
B. break语句可用在if语句中，它可使执行的流程跳出当前的if语句
C. break语句可用在循环体中，它将是执行的流程跳出本层循环
D. break语句可用在switch语句中，它使执行的流程跳出当前switch语句

4.以下描述不正确的是（）。

A. 指针根据其所指向变量的类型的不同，其所占用内存大小也不同
B. 相同类型的指针之间可以相互赋值
C. 指针中存放的实际上是内存单元的地址
D. 可以在指针定义的同时对其进行初始化

5.以下说法中正确的是（）。

A. 当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new
B. C++语言只能用new和delete用于动态内存分配和释放的函数
C. 动态分配的内存空间也可以被初始化
D. 当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间

6.以下说法中不正确的是（）。

A. 构造函数可以对静态数据成员进行初始化
B. 构造函数可以重载
C. 构造函数不可以设置默认参数
D. 构造函数可以在说明类变量时自动执行

7.以下说法中不正确的是（）。

A. 公有继承时基类中的private成员在派生类中仍是private的
B. 保护继承时基类中的public成员在派生类中是protected的
C. 公有继承时基类中的public成员在派生类中仍是public的
D. 私有继承时基类中的public成员在派生类中是private的

在这里插入图片描述
8.以下说法中不正确的是（）。

A. 如果类A是类B的友元，那么类A的所有成员函数都是类B的友元
B. 如果类A是类B的友元，那么类B也是类A的友元
C. 如果函数fun()被说明为类A的友元，那么在fun()中可以访问类A的私有成员
D. 友元关系不能被继承

以下程序的输出结果是（）。

#include<iostream>
using namespace std;
int main() {
    int a=5;
    int *pa=&a;
    int &b=a;
    b++;
    cout<<(*pa)++<<endl;
    return 0;
}

A. 7
B. 5
C. 6
D. 8

10.以下程序的输出结果是（）。

#include <iostream>
void fun(int x, int &y) {
    int t=x;x=y;y=t;
}
int main() {
    int a[2]={100,142};
    fun(a[1],a[0]);
    std::cout<<a[0]<<","<<a[1]<<std::endl;
    return 0;
}

A. 100,100
B. 100,142
C. 142,100
D. 142,142

11.有如下说明：int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;则数值为9的表达式是（）。
A. *p+=9
B. p+8
*C. (p+8)
D. *p+9

12.下列语句中，正确的是（）。
A. char Str="Anhui-hefei";
B. char *Str="Anhui-hefei";
C. char Str[10]="Anhui-hefei";
D. char Str[11]="Anhui-hefei";

13.以下说法中正确的是（）。

A. 从流中获取数据的操作称为插入操作，向流中添加数据的操作称为提取操作
B. 与键盘、屏幕、打印机和通信端口的交互都可以通过流类来实现
C. 输出流有一个名为open的成员函数，其作用是生成一个新的流对象
D. cin是一个预定义的输入流类

从流中获取数据（如 cin >> x）称为提取操作（extraction）向流中添加数据（如 cout << x）称为插入操作（insertion）。
open 成员函数的作用是将流与一个具体文件或设备关联，并不是生成新的流对象。生成新流对象是通过构造函数完成的。
cin 是一个预定义的对象（istream 类的对象），不是类。

14.执行语句序列

int n;
cin >> n;
switch(n) {
    case 1:
    case 2:cout<<'5';
    case 3:
    case 4:cout<<'6';break;
    default:cout<<'7';
}

时，若键盘输入1，则输出结果是（）。
A. 5
B. 6
C. 56
D. 7

15.以下程序的输出结果是（）

#include <iostream>
using namespace std;
int main() {
    cout.fill('*');
    cout.width(8);
    cout.fill('$');
    cout<<123<<endl;
    return 0;
}

A. *****123
B. $$$$$123
C.123$$$$$
D. 123*****

16.以下说法中不正确的是（）。
A. 面向对象是从现实世界中客观存在的事物出发来构造软件系统的
B. 面向对象方法中使用了一些面向过程方法中没有的概念
C. 面向对象方法替代了过程化程序设计方法
D. 面向对象程序设计方法要使用面向对象的程序设计语言

17.以下说法中不正确的是（）。
A. 使用sizeof运算符可以求得某种类型和某个变量在内存中占的字节数，不能求得某个表达式的类型在内存中所占的字节数
B. 没有参数的两个函数是不能重载的
C. 在C++程序中，变量值是可以改变的，变量的地址值是不能改变的
D. 开关语句中各个case和default出现的前后次序不影响执行结果

18.以下说法中不正确的是（）。
A. 动态联编是函数联编的一种方式，它是在运行时来选择联编函数的
B. 函数重载和运算符重载都属于动态联编
C. 动态联编又可称为动态多态性，是通过虚函数实现的
D. 抽象类中至少应该有一个纯虚函数

动态联编（动态绑定）是在程序运行时根据对象的实际类型确定调用哪个函数，与静态联编（编译时确定）相对。
函数重载和运算符重载都是在编译时根据参数类型或个数确定调用哪个函数，属于静态联编（静态多态），不是动态联编
动态多态性通过虚函数机制和继承关系实现，运行时通过虚函数表（vtable）决定调用哪个函数。
抽象类是指含有至少一个纯虚函数（= 0）的类，不能实例化。

已知：B类是A类的公有继承的派生类，以下说法中不正确的是（）。
A. A类的对象就是B类的对象
B. B类对象可以给A类对象赋值
C. B类对象的地址值可以给A类对象指针赋值
D. B类对象可以给A类对象引用赋值
科目: C++
类型: 单选题
答案: A

20.以下说法中正确的是（）。

A. 字符串常量与字符常量的区别仅表现在定义形式上的不同，一个用双撇号，另一个用单撇号
B. 增1和减1运算符不仅可以作用在变量上，也可以作用在表达式上
C. C++程序中，通常使用const来定义符号常量，定义时必须指出类型
D. 关系运算符可以用来比较两个字符的大小，也可以比较两个字符串的大小

21.已知：int swap(int &a,int &b),x=10,y=20;下列调用swap()函数的语句中，编译不会报错的是（）。
A. swap(&x,&y);
B. swap(x+2,y+5);
C. swap(x,y);
D. swap(x++,++y);

22.Void Set(A &a);是类A中一个成员函数的说明，其中A&a的含义是（）。
A. 类A的对象引用a作该函数的参数
B. 类A的对象a的地址值作函数的参数
C. 表达式变量A与变量a按位与作函数参数
D. 指向类A对象指针a作函数参数

23.以下说法中不正确的是（）。
A. 运算符重载是通过对已有的运算符重新定义操作功能来实现的，它是C++语言多态性的一种表现
B. 如果类模板的模板类型参数有多个，除第1个模板类型参数前使用关键字class，其余的模板类型参数前都不使用关键字class
C. 虚函数有继承性，基类中说明的虚函数只要在它的派生类中与它名字相同的，一定是虚函数
D. 一个抽象类中可以包含有多个纯虚函数，一个派生类中也可以包含多个虚函数

在模板参数列表中，每个类型参数前都可以使用 class 或 typename，且可以混用。例如：template<class T, class U typename V> class MyClass { ... };
所以 B 的说法是错误的限制。

以下程序的输出结果是（）。

#include <iostream>
#define MAX(x,y) (x)>(y)?(x):(y)
void main() {
    typedef int IN;
    IN a(3),b(4),c;
    c=MAX(a,b)*2;
    cout<<c<<endl;
}

A. 6
B. 12
C. 8
D. 7

以下程序的输出结果是（）。

#include <iostream>
void main() {
    char str[][4]={"345","789"},*m[2];
    int s(0);
    int i;
    for(i=0;i<2;i++)
        m[i]=str[i];
    for(i=0;i<2;i++)
        for(int j=0;j<4;j+=2)
            s+=m[i][j]-'0';
    cout<<s<<endl;
}

A. 36
B. 12
C. 15
D. 24

26.以下说法中不正确的是（）。
A. 定义派生类可用关键字class或struct。
B. 定义派生类时要指出派生类的类名和基类的类名。
C. 定义派生类时一定要给出继承方式，不能默认。
D. 定义派生类时，类体中给出派生类的成员。

27.以下程序的输出结果是（）。

#include <iostream>
void main() {
    char s[]="bhy543kpm345";
    for(int i=0;s[i]!='\0';i++) {
        if(s[i]>='a'&&s[i]<='z')
            continue;
        cout<<s[i];
    }
    cout<<endl;
}

A. 543345
B. bhykpm
C. bhy543kpm345
D. bhy543

28.以下说法中正确的是（）。
A. 没有返回值的函数不能设置为内联函数
B. 字符指针是指向字符串的指针，可以用字符串常量给字符指针赋值
C. 外部类变量与外部静态类变量的作用域是相同的
D. 定义一个数组没有对它进行初始化，则该数组的元素值都是无意义的

外部变量（extern）具有全局作用域（整个程序可见）
外部静态变量（static 在全局作用域）具有文件作用域（仅当前文件可见）
作用域不同。
对于局部数组，未初始化时元素值是未定义的（垃圾值）。
对于全局或静态数组，未初始化时元素会被默认初始化为 0（对于基本类型）。
所以“都是无意义的”说法不准确。

以下说法中不正确的是（）。
A. 用来给数组进行初始化的初始值表内的数据项的个数必须小于等于数组元素个数
B. C++程序中，通常使用const来定义符号常量，定义时必须指出类型
C. 移位运算符在移位操作中，无论左移还是右移，对移出的空位一律补0
D. 数组某维的大小可以用常量表达式，不可用变量名
以下程序的输出结果是（）。

#include <iostream.h>
void main() {
    int a(10);
    while(--a) {
        if(a==5)
            break;
        if(a%2==0&&a%3==0)
            continue;
        cout<<a<<endl;
    }
}

9
8
7

C. 7
D.

31.下列关于C++的说法中，正确的是（）。
A. C++对于大小写不敏感
B. C++属于解释性语言
C. 任何合法的C语言程序都是合法的C++程序
D. C++支持封装与继承，但是不支持多态

32.下列哪项关键词属于C++所有但是C语言没有的（）。
A. extern
B. virtual
C. and
D. goto

33.有如下枚举类型的定义，下面说法错误的是哪一项( )。
enum fruit{hotdog, apple = 4, beef, orange};
A. fruit c = hotdog; 则c的值为0
B. fruit c = apple; 则c的值为4
C. fruit c = beef; 则c的值为2
D. fruit c = orange; 则c的值为6

enum枚举值默认从 0 开始，但可以手动赋值，后续的值依次 +1。

34.下面所述的四段代码，不能够完成遍历二叉树的是哪一项（打印二叉树所有节点仅一次）（）。假设二叉树的结点定义如下：

struct BiTree {
    int data;
    struct BiTree* left;
    struct BiTree* right;
};

void traversal(struct BiTree *node) {
    if(node == NULL)
        return;
    traversal(node->right);
    cout << node->data << endl;
    traversal(node->left);
}

B. （这里先pop错了）

void traversal(struct BiTree *node) {
    if(node == NULL)
        return;
    stack<BiTree*> s;
    s.push(node);
    while(!s.empty()){
        s.pop();
        cout << s.top()->data << endl;
        if(s.top()->right)
            s.push(s.top()->right);
        if(s.top()->left)
            s.push(s.top()->left);
    }
}

void traversal(struct BiTree *node) {
    if(node == NULL)
        return;
    traversal(node->right);
    traversal(node->left);
    cout << node->data << cout;
}

void traversal(struct BiTree *node) {
    if(node == NULL)
        return;
    queue<BiTree*> s;
    s.push(node);
    while(!s.empty()){
        cout << s.front()->data<< endl;
        if(s.front()->right)
            s.push(s.front()->right);
        if(s.front()->left)
            s.push(s.front()->left);
        s.pop();
    }
}

35.设计一个队列，以链表存储队列的元素。假设队首指针为head，队尾指针为tail，现指针p指向的元素即将入队，请写出正确的入队代码？（）
A. head = p, head = head->next;
B. p->next = head->next, head = p;
C. tail->next = p, tail = p;
D. tail->next = p, p->next = NULL, tail = p;

36.若是x为4，y为9，则(~x)^y的结果是（）。?
A. 1
B. 10
C. 13
D. -14

~x = -5（十进制）
-5 的补码：
5 的二进制：0000 0000 0000 0000 0000 0000 0000 0101
取反：1111 1111 1111 1111 1111 1111 1111 1010
加 1：1111 1111 1111 1111 1111 1111 1111 1011（这是 -5 的补码）
9 的二进制：0000 0000 0000 0000 0000 0000 0000 1001
异或运算（逐位）：
1111 1111 1111 1111 1111 1111 1111 1011 (-5)
0000 0000 0000 0000 0000 0000 0000 1001 (9)
1111 1111 1111 1111 1111 1111 1111 0010
最后再补码转原码所有位置按位取反加1得到14

37.下面关于C++函数的说法中，错误的选项是（）。
A. 函数由函数名称、返回类型、参数、函数体组成，缺一不可
B. 函数声明时参数类型不可省，参数名称不是必要的
C. 有的函数可能没有return关键字
D. C++可以在定义函数时，设置默认参数值

参数列表可以为空
函数声明时可以只写类型不写参数名：int add(int, int); // 正确，只有类型

定义了如下所示的test1类和它的子类test2，下列选项说法错误的是（）。

class test1{
    string name;
public:
    string language;
protected:
    float grade;
};
class test2 : public test1{
public:
    char gender;
    void fun(){
        cout << gender << endl;
        cout << language << endl;
        cout << name << endl;
        cout << grade << endl;
    }
};

A. fun()函数中变量gender可以正常输出
B. fun()函数中变量language可以正常输出
C. fun()函数中变量name可以正常输出
D. fun()函数中变量grade可以正常输出

39.下列C++程序实现了使用迭代器访问并输出数组vec的元素，空白处应该补充的代码是（）。

vector<int>::iterator v = vec.begin();
while( v != vec.end()) {
    ________
    v++;
}

A. cout << *v << endl;
B. cout << v << endl;
C. cout << &v << endl;
D. 其他选项均可以

40.关于下列几行C++代码，说法正确的是（）。

string c1 = "a";
string c2 = "b";
char c3 = 'c';
char c4 = 'd';

A. 直接输出c1 + c2的结果是195
B. 直接输出c3 + c4 的结果是199
C. 直接输出c1 + c3 的结果是196
D. 其他选项说法均错误

41.C++STL的核心不包括以下哪个选项（）。
A. 迭代器
B. 算法
C. 指针
D. 容器

42.关于下列C++代码的时间复杂度与空间复杂度的说法，正确的是（）。

struct node{
    int x, time;
};
int solve(int N, vector<int>& A) {
    stack<node> s;
    int res = 0;
    for(int i = N - 1; i >= 0; i--){
        int time = 0;
        while(!s.empty() && A[i] > s.top().x){
            time = max(s.top().time, time + 1);
            s.pop();
        }
        s.push({A[i], time});
        res = max(res, time);
    }
    return res;
}

A. 时间复杂度为 $O (N)$ ，空间复杂度为 $O (N)$
B. 时间复杂度为 $O (2 N)$ ，空间复杂度为 $O (N)$
C. 时间复杂度为 $O(N^2)$ ，空间复杂度为 $O (N /2)$
D. 时间复杂度为 $O (l o g N)$ ，空间复杂度为 $O (N /2)$
科目: C++
类型: 单选题
答案: A

43.下列关于C++常用标准库的一些说法，错误的是哪一项（）。
A. cout控制输出精度需要使用
B. 标准错误流cerr属于
C. 字符串截取函数substr()属于
D. 一个c++工程里不可以有两个或多个命名空间的

编程题

移动字符

假定输入的字符串中只包含字母和@号，请编写程序，将字符串中的前导@符全部移到字符串的尾部。例如：字符串中的内容为：@@@@ab@CD@G@@@,移动后，字符串中的内容为：ab@CD@G@@@@@@@。在编写程序时，不得使用C++语言提供的字符串函数。（输入的字符串不含空格，且字符串长度不大于1000）

输入样例1：

@@@@ab@CD@G@@@

输出样例1：

ab@CD@G@@@@@@@

输入样例2：

abc@d

输出样例2：

abc@d

$C o d e$

#include <iostream>

using namespace std;

int main() {
    string s;
    cin >> s;
    if (s[0] != '@') {
        cout << s;
        return 0;
    }
    int cnt = 1, i = 1, n = s.size();
    for (i = 1; i < n && s[i] == '@'; i++) cnt ++;
    while (i < s.size()) cout << s[i ++];
    while (cnt --) cout << '@';
}

求组合数

编写程序，从键盘上输入两个正整数，其中大的为m小的为n根据以下公式求P的值，并输出。( $0 < n < m <= 30$ )其中 $P = m ！ / （ n! (m - n)! ）$

输入样例1：

12 8

输出样例1：

输入样例2：

27 30

输出样例2：

$C o d e$

#include <bits/stdc++.h>

using namespace std;

const int N = 2e3 + 7, mod = 1e9 + 7;

int f[N][N];

void get() {
    for (int i = 0; i <= 2000; i++) {
        for (int j = 0; j <= i; j++) {
            if (!j) f[i][j] = 1;
            else f[i][j] = (f[i - 1][j - 1] + f[i - 1][j]);
        }
    }
}

int main() {
    int t = 1; 
    // cin >> t;
    get();
    while (t --) {
        int a, b;
        cin >> a >> b;
        if (a < b) swap(a, b);
        cout << f[a][b] << endl;
    }
}

数组周边元素的和

定义 $N \times N$ 的二维数组，数组元素（整数）通过键盘输入，请编写程序，求出数组周边元素的和值，并输出。（ $2 <= N <= 100$ )

输入格式

第1行：输入 $N$ 。其中 $2 <= N <= 100$
第2到 $N + 1$ 行，每行输入 $N$ 的元素，元素之间用两个空格分隔。

输出格式

1行：一个整数。

输入样例1

输出样例1

输入样例2

输出样例2

$C o d e$

#include <iostream>

using namespace std;

const int N = 1e2 + 7;

int n;
int a[N][N];

int main() {
    cin >> n;
    int sum = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            cin >> a[i][j];
    
    int res = 0;
    for (int i = 1; i <= n; i++) res += a[1][i] + a[n][i];
    for (int i = 2; i < n; i++) res += a[i][1] + a[i][n];
    cout << res << endl;

    return 0;
}

进制转换

编写程序将一个十进制数N转化为八进制，要求：定义Septinary类（八进制类），来表示一个八进制的数及其相关操作，和十进制的数“逢十进一”类似，八进制的数定义为“逢八进一"。
Septinary类的数据成员说明如下：

char *data;//存放八进制数的每一位数，data[0]为最高位，且八进制的位数不超过99位。
CreateSeptinary函数由构造函数调用，用于将作为参数传入的十进制数转化为八进制数，并将八进制数的每一位存入data数组中。
定义numberToChar成员函数，将一个 $[0, 7]$ 之间的数转化为对应的ASCII码值。
十进制数（大于等于0的整数）在main函数中输入，并在main函数中输出转化后的八进制数。

输入样例1：

输入样例2：

输出样例1：

输出样例2：

$C o d e$

#include <bits/stdc++.h>

using namespace std;

class Septinary {
public:
    char *data;
    int x;
    Septinary(int x) {
        this->x = x;
        CreateSeptinary();
    }
    ~Septinary() {
        delete data;
    }
    void CreateSeptinary() {
        int num = this->x;
        data = new char[100];
        int cnt = 0;
        while (num) {
            data[cnt ++] = numberToChar(num % 8);
            num /= 8;
        }
        for (int i = cnt - 1; i >= 0; i--) {
            cout << data[i];
        }
    }
    char numberToChar(int x) {
        return (char)(x + '0');
    }
};

int main() {
    int n;
    cin >> n;
    Septinary s(n);
    return 0;
}