本文所涉及的题目均为基于个人学习和理解重新表述的内容，仅供学习交流之用，不代表任何实际考试题目。如有雷同，纯属巧合。

1、不定项选择题

1.1

下列哪个命令可用于获取 shell 命令的使用说明？==（D）==

1. more
2. help
3. pwd
4. man

解答：

more 用于分页查看文件内容 help 并非标准 shell 命令 pwd 用于显示当前工作目录的完整路径 man 可用于查看命令的详细手册，因此应选择 D 选项

1.2

关于差分信号，下列哪些说法是正确的？==（ABC）==

1. 可有效降低电磁干扰（EMI）
2. 便于识别微弱信号
3. 具备较强的抗干扰能力
4. 曼切斯特编码属于差分信号的一种

解答：

曼切斯特编码并不属于差分信号的范畴

1.3

以下关于 Linux 命令的描述，哪些是错误的？==（ACD）==

1. rm 命令可直接删除目录
2. comm 命令可用于比较两个文本文件中的相同内容
3. df 命令可用于查看当前目录占用的磁盘空间大小
4. ln -s a.txt b.txt 命令创建的符号链接名称为 a.txt

解答：

rm 默认仅删除文件，若要删除目录需使用 -r 选项，因此 A 选项错误 comm 用于对比两个已排序文件的内容，B 选项正确 df 用于查看整个文件系统的磁盘使用情况，而非单个目录，C 选项错误 ln -s a.txt b.txt 实际作用是创建 b.txt 作为 a.txt 的符号链接，D 选项错误

1.4

已定义类 A、B、C、D，以下程序运行后，其析构函数的调用顺序是？==（A）==

C c;

void main()
{
    A* pa = new A();
    B b;
    static D d;
    delete pa;
}

1. A B D C
2. A D B C
3. A C D B
4. A D C B

解答：

c 是全局对象，pa 和 b 是局部对象，d 是静态局部对象，构造顺序为 C->A->B->D，析构顺序相反，为 A->B->D->C

1. 局部对象的析构顺序与构造顺序相反，在作用域结束时执行
2. 全局对象与静态对象在程序结束时析构，顺序也与构造相反

1.8

一个空类的实例在内存中的占用大小是多少字节？==（D）==

1. 4
2. 8
3. 0
4. 1

解答：

C++ 规定每个对象必须占据独立的内存地址，因此即便是空类，也至少会被分配 1 字节的存储空间

1.9

嵌入式系统中最常采用的数据传输方式是？==（C）==

1. 查询方式
2. I/O 处理机
3. 直接存储器访问（DMA）
4. 中断方式

1.10

在 32 位编译环境下，以下程序的可能输出是多少？==（C）==

#include <iostream>
#pragma pack(push)
#pragma pack(4)

struct Foo {
    char m1;
    long m2;
    int m3;
};

#pragma pack(pop)

int main() {
    std::cout << sizeof(Foo) << std::endl;
    return 0;
}

1. 13
2. 9
3. 12
4. 24

解答：

#pragma pack(4) 指定了 4 字节对齐规则。在 32 位编译环境下：

• m1 占 1 字节，但会被填充到 4 字节对齐
• m2 占 4 字节
• m3 占 4 字节
• 总大小为 12 字节

1.11

下列哪种方式可以正确地进行字符串赋值？==（C）==

1. char *sp; *sp="Dream future!";
2. char s[20]; s="Dream future!";
3. char *sp="Dream future!";
4. char s[20];*s="Dream future!";

解答：

1. 编译错误：无效的类型转换（从 'const char*' 到 'char'）
2. 数组名不能被赋值
3. 正确的赋值方式
4. 编译错误：无效的类型转换（从 'const char*' 到 'char'）

1.12

阅读代码并选择正确的选项 ==（）==

#include <iostream>

class MyBase {
public:
    virtual void SayHello() {
        std::cout << "MyBase Hello.";
    }
};

class Worker : public MyBase {
public:
    Worker() {
        SayHello(); 
    }

    void SayHello() { 
        std::cout << "Worker Hello.";
    }
};

int main() {
    auto w = new Worker; 
}

解答：

代码原始版本中 Worker 构造函数错误，应改为 Worker()

1.17

crontab 文件由 6 个字段组成，每个字段之间用空格分隔，下列哪种排列方式是正确的？==（A）==

1. MIN HOUR DAY MONTH DAYOFWEEK COMMAND
2. COMMAND YEAR MONTH DAY HOUR MIN
3. COMMAND HOUR DAY MONTH DAYOFWEEK
4. MIN HOUR DAY MONTH YEAR COMMAND

解答：

crontab 格式依次为：分钟 小时 日期 月份 星期 执行命令

1.18

关于 C 语言，以下哪个说法是正确的？==（D）==

1. int* p1; 可以这样赋值 *p1=5;
2. "1" 占 1 个字节
3. 1 bit = 8 byte
4. printf 中使用格式符 "%5s" ，如果输出的字符串长度大于 5，则按原字符串长度输出

解答：

1. int* p1; 只是声明了指针变量，但未初始化，直接赋值会导致未定义行为
2. "1" 不是字符 '1'，而是字符串 "1\0"，因此占用两个字节
3. 1 字节（byte）等于 8 位（bit），而不是 8 字节
4. "%5s" 指定最小宽度为 5，但不会截断超出长度的字符串

1.19

telnet 连接端口后，如何手动退出？==（C）==

1. quit
2. Exit
3. ctrl+]
4. ctrl+q

1.20

以下 C++ 代码的输出正确选项是 ==（B）==

#include <iostream>

class A 
{
public:
    A() { std::cout << "a"; }
    ~A() { std::cout << "b"; }
    A(const A&) { std::cout << "c"; }
    A& operator=(const A&) { std::cout << "d"; return *this; }
};

int main() {
    A a;
    auto f = [=]() { A b = a; };
    f();
}

1. 输出字符串中，a、c 和 d 的总数与 b 数量一致;
2. 输出字符串中，a 和 c 的总数与 b 数量一致;
3. 输出字符串中，a 数量为 2；
4. 输出字符串中，d 数量为 1；

解答：

A() 是类 A 的默认构造函数，A(const A&) 是拷贝构造函数，~A() 是析构函数

代码执行过程：

1. A a; 调用默认构造函数，输出 a
2. f(); 执行 A b = a;，调用拷贝构造函数，输出 c
3. 作用域结束，b 被析构，输出 b
4. main 结束，a 被析构，输出 b
5. 最终输出为 acbb

2、编程题

2.1

题目：

给定一个字符串，将字符串中的每个单词逐个翻转

示例：

1. 输入：“I Am a Programmer!"
2. 结果：“I mA a remmargorP!
3. 函数形式如下：char* ReverseString(char* Source)

解答：

1. 以空格分割每个单词
2. 创建函数用于反转每个单词
3. 增加判断是否为字母的函数，确保句子最后的标点符号不会被翻转

#include <stdio.h>  
#include <string.h>  
  
// 判断字符是否为字母的函数  
int isAlpha(char c) {  
    // 检查是否为大写字母或小写字母  
    if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {  
		// 是字母 
		return 1;  
    } else {  
		// 不是字母 
		return 0;  
    }  
}  
  
// 辅助函数，用于翻转字符串中从 start 到 end 的部分  
void reverseWord(char* str, int start, int end) {  
	while (start < end) {  
		char temp = str[start];  
		str[start] = str[end];  
		str[end] = temp;  
		start++;  
		end--;  
	}  
}  
  
// 主函数，用于翻转字符串中的每个单词  
char* ReverseString(char* source) {  
	int n = strlen(source);  
	int start = 0;  
	
	for (int i = 0; i <= n; ++i) {  
	   // 检查空格或字符串末尾  
	   if (source[i] == ' ' || source[i] == '\0' || !isAlpha(source[i])) {  
		  reverseWord(source, start, i - 1);  
		  // 移动到下一个单词的起始位置  
		  start = i + 1; 
	   }  
	}  
	
    return source;  
}

2.2

给定一个正整数 n ，你可以做如下操作：

4. 如果 n 是偶数，则用 n/2 替代 n ；
5. 如果 n 是奇数，则可以用 n+1 或 n-1 替换 n ；
6. 返回 n 变为 1 所需的最小替换次数；

示例：

7. 输入：n=8
8. 输出：3
9. 解释：8 -> 4 -> 2 -> 1

解答（存疑）：

#include <stdio.h>

int minStepsToOne(int n) {
    int steps = 0;

    while (n != 1) {
		// 如果是偶数，除以2
        if (n % 2 == 0) {
            n /= 2;  
        } else {
			// 特殊情况：3 变为 2 或 4，选择 2 更优
            if (n == 3) {
                n -= 1;
			// 或选择 n-1
            } else {
                n += 1;  
            }
        }
        steps++;
    }
    
    return steps;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = minStepsToOne(n);
    printf("%d\r\n", result);
    return 0;
}