20240719 CVTE 笔试

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

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

1、不定项选择题

1.1

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

more
help
pwd
man

解答：

more，以翻页的形式查看某文件中的内容
help，无此命令
pwd，显示当前工作目录的完整路径
man，查看命令的手册页，因此选 D 选项

1.2

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

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

解答：

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

1.3

下列说法错误的是（ACD）

rm 命令可以用来删除目录
comm 命令打印两个文本文件中的相同内容
df 命令可以查看当前目录占用磁盘空间大小
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; 
}

A B D C
A D B C
A C D B
A D C B

解答：

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

局部对象会在作用域结束时按照构造时相反的顺序析构

全局对象、静态对象会在程序结束时按照构造时相反的顺序析构

1.8

一个空类的实例占用多少个字节的内存？（D）

解答：

C++ 标准要求每个对象在内存中必须有一个唯一的地址，编译器会分配至少 1 个字节的内存空间

1.9

嵌入式系统最常用的数据传送方式是（C）

查询
I/O处理机
DMA
中断

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

解答：

#pragma pack(4) 确定了内存对齐数为 4 ，在 32 位编译环境下，m1 占用 1 字节，m2 占用 4 字节，m3 占用 4 字节，为保证内存对齐，m1 实际上占用了 4 字节

1.11

下列语句或语句组中，能正确进行字符串赋值的是（C）

char *sp; *sp="Dream future!";
char s[20]; s="Dream future!";
char *sp="Dream future!";
char s[20];*s="Dream future!";

解答：

error: invalid conversion from 'const char*' to 'char'

数组名不可赋值

正确

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）

MIN HOUR DAY MONTH DAYOFWEEK COMMAND
COMMAND YEAR MONTH DAY HOUR MIN
COMMAND HOUR DAY MONTH DAYOFWEEK
MIN HOUR DAY MONTH YEAR COMMAND

解答：

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

1.18

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

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

解答：

int* p1; 定义了一个 int * 型指针，但是未对其初始化，因此无法对其赋值

“1” 不是字符 '1'，而是字符 ‘1’ + ‘\0’ ，因此其占用两个字节

1 字节（byte） == 8 位（bit）

1.19

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

quit
Exit
ctrl+]
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();
}

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

解答：

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

执行 A a; 时使用默认构造函数，执行 f(); 时使用拷贝构造函数，程序结束时 a 和 b 都执行析构函数，所以最终程序应该输出 acbb

2、编程题

2.1

题目：

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

示例：

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

解答：

以空格分割每个单词

创建函数用于反转每个单词

增加判断是否为字母的函数，确保句子最后的标点符号不会被翻转

#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 ，你可以做如下操作：

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

示例：

输入：n=8
输出：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;
}

posted @ 2024-11-05 08:42 OSnotes 阅读(85) 评论(0) 编辑收藏举报

刷新页面返回顶部

lc-guo