大华嵌入式软件开发工程师笔试 9-17

《嵌入式软件开发笔试与面试手册》：https://blog.nowcoder.net/zhuanlan/jvN8gj

《嵌入式软件笔试-2023年真题汇总》：https://blog.nowcoder.net/zhuanlan/0oDWVm

单选题

1.语句switch(c)中的c不能是哪种数据类型()

char

char*

time_t

unsigned long long

解释：char* - 指针类型，不能作为 switch 表达式。

2.下列函数中,可以作为虚函数的是:

全局静态函数

普通成员函数

静态成员函数

构造函数

解释：

全局静态函数 - 全局函数和静态函数不属于任何类的实例，因此不能是虚函数。

普通成员函数 - 普通成员函数可以是虚函数，这是实现多态的基础。

静态成员函数 - 静态成员函数不与类的任何特定对象关联，因此它不能是虚函数。

构造函数 - 在C++中，构造函数不能被声明为虚函数。

3.下面哪个操作是安全的,不会导致内存操作越界

void func(char *p) {
    char a[20] = {0};
    strcpy(a, p);
}
这个函数使用 strcpy 来复制字符串，但没有检查 p 的长度。如果 p 的长度超过19个字符（包括空字符），这将导致数组 a 越界，是不安全的。

void func(char *p) {
    int len = strlen(p) - 1;
    char *a = (char*) malloc(len);
    memcpy(a, p, len);
}
这个函数计算 strlen(p) - 1 作为长度，可能是为了去掉字符串末尾的空字符，但这样会导致最后一个字符丢失，同时分配的内存不包括终止的空字符，也是不安全的。

void func(char *p) {
    int len = strlen(p);
    char *a = (char*) malloc(len + 1);
    memcpy(a, p, len);
    a[len] = '\0';
}
这个函数正确地计算了长度，为字符串分配了足够的内存（包括空字符），并确保了字符串以空字符结束。这是一个安全的内存操作。

void func(char *p) {
    char a[100] = {0};
    sprintf(a, "%s%d", p, 1);
}
这个函数使用 sprintf 将字符串和一个整数格式化后存入数组 a。尽管数组大小为100，但如果 p 的长度非常大，仍有可能导致数组越界。

 

4.如下代码，打印输出的结果是

typedef struct
{
    int a:8;
    int b:8;
    int c:8;
    int d:8;
} field;

int main(void)
{
  field t1;
  memset(&t1,0,sizeof(t1));
  t1.a = 257;
  printf("%d %d\n", t1.a, t1.b);
  return 0;
}

A 257 0

B 255 2

C

0 2

D

1 0

 

5.std::map<key,value>,当key值不是非基本类型时，需要实现哪个函数?

operator<()

operator<<()

operator>>()

operator>()

 

6.有关析构函数的说法不正确的是:

析构函数有且仅有一个

析构函数和构造函数一样可以有形参

析构函数的功能是用来释放一个对象

析构函数无任何函数类型

解释：析构函数不能有参数

 

7.以下错误的行是:

std::cout<<"测试\n";

operator<<(std::cout,"测试\n");

endl(std::cout);

std::cout<<endl;

解释：错误地将 endl 当作函数直接调用

8.下列关于函数模板的描述中,正确的是

函数模板的类型参数与函数的参数是同一个概念

使用函数模板定义的函数没有返回类型

函数模板的类型参数与函数的参数相同

一个类定义中,只要有一个函数模板，则这个类是类模板

解释：

1、函数模板的类型参数是用于指定函数参数和返回值的类型，而函数的参数是实际传递给函数的值。类型参数和函数参数是两个不同的概念。

2、函数模板可以有返回类型，而这个类型可以是固定的，如 int，double 等，或者由模板的类型参数决定。

4、一个类可以包含函数模板而本身不是类模板。类模板是指整个类的定义依赖于类型参数，而不是单独的函数。

 

9.

#include <iostream>

struct X
{
    X() { std::cout << "1"; }
    X(const X&) { std::cout << "3"; }
    ~X() { std::cout << "2"; }
    void f() { std::cout << "4"; }
};

int main()
{
    X object;
    X copy = object;
    object.f();
    return 0; 
}

11422

13422

12342

13242

 

10.

#include <iostream>

class A
{
public:
    A()
    {
        std::cout << "A Construct\n";
        func_init();
    }

    virtual ~A()
    {
        std::cout << "A Destruct\n";
        func_deinit();
    }

    virtual void func_init()
    {
        std::cout << "this is A func_init\n";
    }

    virtual void func_deinit()
    {
        std::cout << "this is A func_deinit\n";
    }
};

class B : public A
{
public:
    B()
    {
        std::cout << "B Construct\n";
        func_init();
    }

    ~B() override
    {
        std::cout << "B Destruct\n";
        func_deinit();
    }

    void func_init() override
    {
        std::cout << "this is B func_init\n";
    }

    void func_deinit() override
    {
        std::cout << "this is B func_deinit\n";
    }
};

int main()
{
    A* p = new B();
    delete p;
    return 0;
}

以上代码的输出是:

A Constuct this is B func_init B Construct this is B func_init B Destruct this is B func_deinit A Destruct this is B func_deinit

A Construct this is A func_init B Construct this is B func_init B Destruct this is B func_deinit A Destruct this is A func_deinit

A Construct this is B func_init B Construct this is B func_init A Destruct this is B func deinit B Destruct this is B func_deinit

B Construct this is A func_init A Construct this is B func init A Destruct this is B func deinit B Destruct this is A func_deinit

 

11.

template<typename T>

void print(T&& v)

{}

函数中，如果传入的是一个std::string &进来,那么v会被推导成:

string &&

string &

string

string *

解释：

std::string& （一个字符串的左值引用）

当一个左值引用传递给类型为 T&& 的参数时，根据模板推导规则和引用折叠规则，T 会被推导为 std::string&，而不是 std::string 或 std::string&&。引用折叠规则指出，左值引用到左值引用仍然是一个左值引用 (& && 折叠为 &)。

因此，v 的类型在这种情况下会被推导为 std::string &。

 

12. test.cpp内容如下

#include <iostream>
using namespace std;
int show(char* p) {
    return sizeof(p);
}

int main() {
    char p[2];
    cout << sizeof(p) << " " << show(p) << endl;
    return 0;
}

用g++ -m32 test.cpp编译执行结果是?

22

24

44

28

 

13.下面代码运行输出是

#include <stdio.h>

int main()
{
    int a[6] = {1, 2, 3, 4, 5, 6};
    int *p = (int*)(&a + 1);
    printf("%d, %d\n", *(a + 1), *(p - 2));
    return 0;
}

2,4

2,5

2,6

3,4

 

14.以下叙述中正确的是():

函数的定义不可以嵌套,但函数的调用可以嵌套

main函数必须放在其他函数之前

所有被调用的函数定要在调用之前进行定义

在C语言程序中有调用关系的所有函数必须放在同一个源文件中

解释：

2、main 函数的位置在源文件中不是固定的。它不需要放在其他函数定义之前。编译器会在整个源文件或项目中寻找 ma