20240719 CVTE 笔试

---

岗位：嵌入式软件开发工程师（Linux方向）

题型：20 道不定项选择题，2 道编程题

---

1、不定项选择题

1.1

如下哪个命令可以帮助你知道 shell 的用法 （D）

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

解答：

more，以翻页的形式查看某文件中的内容

help，无此命令

pwd，显示当前工作目录的完整路径

man，查看命令的手册页，因此选 D 选项

1.2

关于差分信号的理解正确的是 （ABC）

1. 差分信号有减少 EMI（电磁干扰）
2. 差分信号能较容易地识别小信号
3. 差分信号抗干扰能力较强
4. 曼切斯特编码是差分信号的一种

解答：

曼切斯特编码不是差分信号的一种

1.3

下列说法错误的是 （ACD）

1. rm 命令可以用来删除目录
2. comm 命令打印两个文本文件中的相同内容
3. df 命令可以查看当前目录占用磁盘空间大小
4. ln -s a.txt b.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 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 字节，m2 占用 4 字节，m3 占用 4 字节，为保证内存对齐，m1 实际上占用了 4 字节

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. error: invalid conversion from 'const char*' to 'char'
2. 数组名不可赋值
3. 正确
4. error: invalid conversion from 'const char*' to 'char'

1.12

阅读代码选择正确的选型 （）

#include <iostream>

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

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

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

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

解答：

这道题可能存在问题，Worker 的构造函数不能是 MyBase() 而应该是 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

解答：

分钟 小时 第几日 月份 一个星期中的第几天 要执行的程序

1.18

关于 C 语言正确的是 （D）

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

解答：

1. int* p1; 定义了一个 int * 型指针，但是未对其初始化，因此无法对其赋值
2. “1” 不是字符 '1'，而是字符 ‘1’ + ‘\0’ ，因此其占用两个字节
3. 1 字节（byte） == 8 位（bit）

1.19

telnet 一个端口的时候，如何手动退出 （C）

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

1.20

如下代码，正确的选项是 （B）

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; }
};

void 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 的拷贝构造函数，~A() 为其析构函数

执行 A a; 时使用默认构造函数，执行 f(); 时使用拷贝构造函数，程序结束时 a 和 b 都执行析构函数，所以最终程序应该输出 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 ，你可以做如下操作：

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

示例：

1. 输入：n=8
2. 输出：3
3. 解释：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;
}