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(); 时使用拷贝构造函数,程序结束时 ab 都执行析构函数,所以最终程序应该输出 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;
}
posted @ 2024-11-05 08:42  OSnotes  阅读(96)  评论(1编辑  收藏  举报