发表于：2021-01-16 作者：Jasonangel 来源：：嵌入式Linux系统开发

一、前言

本系列将按类别对题目进行分类整理，重要的地方标上星星，这样有利于大家打下坚实的基础。

本文比较深入，需要花时间去理解，保证都是必考题。文章较长，可以先收藏，找个大块时间看。一遍看不懂可以多看几遍。

下面分享16个重要知识点。

二、C/C++题目

1、new和malloc

做嵌入式，对于内存是十分在意的，因为可用内存有限，所以嵌入式笔试面试题目，内存的题目高频。

1)malloc和free是c++/c语言的库函数，需要头文件支持stdlib.h;new和delete是C++的关键字，不需要头文件，需要编译器支持;

2)使用new操作符申请内存分配时，无需指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地支持所需内存的大小。

3)new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无需进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void*，需要通过强制类型转换将void*指针转换成我们需要的类型。

4)new内存分配失败时，会抛出bad_alloc异常。malloc分配内存失败时返回NULL。

2、在1G内存的计算机中能否malloc(1.2G)?为什么?(2021浙江大华二面问题)

答：是有可能申请1.2G的内存的。

解析：回答这个问题前需要知道malloc的作用和原理，应用程序通过malloc函数可以向程序的虚拟空间申请一块虚拟地址空间，与物理内存没有直接关系，得到的是在虚拟地址空间中的地址，之后程序运行所提供的物理内存是由操作系统完成的。

3 、extern”C” 的作用

我们可以在C++中使用C的已编译好的函数模块，这时候就需要用到extern”C”。也就是extern“C” 都是在c++文件里添加的。

extern在链接阶段起作用(四大阶段：预处理--编译--汇编--链接)。

4、strcat、strncat、strcmp、strcpy哪些函数会导致内存溢出?如何改进?(2021浙江大华二面问题)

strcpy函数会导致内存溢出。

strcpy拷贝函数不安全，他不做任何的检查措施，也不判断拷贝大小，不判断目的地址内存是否够用。

1. char *strcpy（char *strDest，const char *strSrc） 

strncpy拷贝函数，虽然计算了复制的大小，但是也不安全，没有检查目标的边界。

1. strncpy(dest, src, sizeof(dest));  

strncpy_s是安全的

strcmp(str1,str2)，是比较函数，若str1=str2，则返回零;若str1

strncat()主要功能是在字符串的结尾追加n个字符。

1. char * strncat(char *dest, const char *src, size_t n); 

strcat()函数主要用来将两个char类型连接。例如：

1. char d[20]="Golden"; 
2. char s[20]="View"; 
3. strcat(d,s); 
4. //打印d 
5. printf("%s",d); 

输出 d 为 GoldenView (中间无空格)

延伸：

memcpy拷贝函数，它与strcpy的区别就是memcpy可以拷贝任意类型的数据，strcpy只能拷贝字符串类型。

memcpy 函数用于把资源内存(src所指向的内存区域)拷贝到目标内存(dest所指向的内存区域);有一个size变量控制拷贝的字节数;

函数原型：

1. void *memcpy(void *dest, void *src, unsigned int count); 

5 、static的用法(定义和用途)(必考)

1)用static修饰局部变量：使其变为静态存储方式(静态数据区)，那么这个局部变量在函数执行完成之后不会被释放，而是继续保留在内存中。

2)用static修饰全局变量：使其只在本文件内部有效，而其他文件不可连接或引用该变量。

3)用static修饰函数：对函数的连接方式产生影响，使得函数只在本文件内部有效，对其他文件是不可见的(这一点在大工程中很重要很重要，避免很多麻烦，很常见)。这样的函数又叫作静态函数。使用静态函数的好处是，不用担心与其他文件的同名函数产生干扰，另外也是对函数本身的一种保护机制。

6、const的用法(定义和用途)(必考)

const主要用来修饰变量、函数形参和类成员函数：

1)用const修饰常量：定义时就初始化，以后不能更改。

2)用const修饰形参：func(const int a){};该形参在函数里不能改变

3)用const修饰类成员函数：该函数对成员变量只能进行只读操作，就是const类成员函数是不能修改成员变量的数值的。

被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

参考一个大佬的回答:

我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。如果应试者能正确回答这个问题，我将问他一个附加的问题：下面的声明都是什么意思?

1. const int a; 
2. int const a; 
3. const int *a; 
4. int * const a; 
5. int const * a const; 

前两个的作用是一样，a是一个常整型数。

第三个意味着a是一个指向常整型数的指针(也就是，整型数是不可修改的，但指针可以)。

第四个意思a是一个指向整型数的常指针(也就是说，指针指向的整型数是可以修改的，但指针是不可修改的)。

最后一个意味着a是一个指向常整型数的常指针(也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的)。

7、volatile作用和用法

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量在内存中的值，而不是使用保存在寄存器里的备份(虽然读写寄存器比读写内存快)。

回答不出这个问题的人是不会被雇佣的。这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。

以下几种情况都会用到volatile：

1、并行设备的硬件寄存器(如：状态寄存器)2、一个中断服务子程序中会访问到的非自动变量3、多线程应用中被几个任务共享的变量

8、const常量和#define的区别(编译阶段、安全性、内存占用等)

用#define max 100 ; 定义的常量是没有类型的(不进行类型安全检查，可能会产生意想不到的错误)，所给出的是一个立即数，编译器只是把所定义的常量值与所定义的常量的名字联系起来，define所定义的宏变量在预处理阶段的时候进行替换，在程序中使用到该常量的地方都要进行拷贝替换;

用const int max = 255 ; 定义的常量有类型(编译时会进行类型检查)名字，存放在内存的静态区域中，在编译时确定其值。在程序运行过程中const变量只有一个拷贝，而#define所定义的宏变量却有多个拷贝，所以宏定义在程序运行过程中所消耗的内存要比const变量的大得多

9、变量的作用域(全局变量和局部变量)

全局变量：在所有函数体的外部定义的，程序的所在部分(甚至其它文件中的代码)都可以使用。全局变量不受作用域的影响(也就是说，全局变量的生命期一直到程序的结束)。

局部变量：出现在一个作用域内，它们是局限于一个函数的。局部变量经常被称为自动变量，因为它们在进入作用域时自动生成，离开作用域时自动消失。关键字auto可以显式地说明这个问题，但是局部变量默认为auto，所以没有必要声明为auto。

局部变量可以和全局变量重名，在局部变量作用域范围内，全局变量失效，采用的是局部变量的值。

10、sizeof 与strlen (字符串，数组)

1.如果是数组

1. #include<stdio.h> 
2. int main() 
3. { 
4.     int a[5]={1,2,3,4,5}; 
5.     printf(“sizeof  数组名=%d\n”,sizeof(a)); 
6.     printf(“sizeof *数组名=%d\n”,sizeof(*a)); 
7. } 

运行结果

1. sizeof  数组名=20 
2. sizeof *数组名=4 

2.如果是指针，sizeof只会检测到是指针的类型，指针都是占用4个字节的空间(32位机)。

sizeof是什么?是一个操作符,也是关键字，就不是一个函数，这和strlen()不同，strlen()是一个函数。

那么sizeof的作用是什么?返回一个对象或者类型所占的内存字节数。我们会对sizeof()中的数据或者指针做运算吗?基本不会。例如sizeof(1+2.0),直接检测到其中类型是double,即是sizeof(double) = 8。如果是指针，sizeof只会检测到是指针的类型，指针都是占用4个字节的空间(32位机)。

1. char *p = "sadasdasd"; 
2. sizeof(p):4 
3. sizeof(*p):1//指向一个char类型的 

除非使用strlen()，仅对字符串有效，直到'\0'为止了，计数结果不包括\0。

要是非要使用sizeof来得到指向内容的大小，就得使用数组名才行， 如

1. char a[10]; 
2. sizeof(a):10  //检测到a是一个数组的类型。 

 

关于strlen()，它是一个函数，考察的比较简单：

1. strlen “\n\t\tag\AAtang” 

答案：11

11、经典的sizeof(struct)和sizeof(union)内存对齐

内存对齐作用：

1.平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2.性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。

结构体struct内存对齐的3大规则:

1.对于结构体的各个成员，第一个成员的偏移量是0，排列在后面的成员其当前偏移量必须是当前成员类型的整数倍;

2.结构体内所有数据成员各自内存对齐后，结构体本身还要进行一次内存对齐，保证整个结构体占用内存大小是结构体内最大数据成员的最小整数倍;

3.如程序中有#pragma pack(n)预编译指令，则所有成员对齐以n字节为准(即偏移量是n的整数倍)，不再考虑当前类型以及最大结构体内类型。

1. #pragma pack(1) 
2.   
3. struct fun{ 
4.   int i; 
5.   double d; 
6.   char c; 
7. }; 

sizeof(fun) = 13

1. struct CAT_s 
2. { 
3.     int ld; 
4.     char Color; 
5.     unsigned short Age; 
6.     char *Name; 
7.     void(*Jump)(void); 
8. }Garfield; 

1.使用32位编译，int占4， char 占1， unsigned short 占2，char* 占4，函数指针占4个，由于是32位编译是4字节对齐，所以该结构体占16个字节。(说明：按几字节对齐，是根据结构体的最长类型决定的，这里是int是最长的字节，所以按4字节对齐);

2.使用64位编译 ，int占4， char 占1， unsigned short 占2，char* 占8，函数指针占8个，由于是64位编译是8字节对齐(说明：按几字节对齐，是根据结构体的最长类型决定的，这里是函数指针是最长的字节，所以按8字节对齐)所以该结构体占24个字节。

1. //64位 
2. struct C  
3. {  
4.  double t;   //8   1111 1111 
5.  char b;  //1      1 
6.  int a;   //4      0001111   
7.  short c;  //2     11000000 
8. };   
9.  sizeof(C) = 24;  //注意：1 4 2 不能拼在一起 

char是1，然后在int之前，地址偏移量得是4的倍数，所以char后面补三个字节，也就是char占了4个字节，然后int四个字节，最后是short，只占两个字节，但是总的偏移量得是double的倍数，也就是8的倍数，所以short后面补六个字节

联合体union内存对齐的2大规则:

1.找到占用字节最多的成员;

2.union的字节数必须是占用字节最多的成员的字节的倍数，而且需要能够容纳其他的成员

1. //x64 
2. typedef union { 
3.     long i; 
4.     int k[5]; 
5.     char c; 
6. }D 

要计算union的大小,首先要找到占用字节最多的成员,本例中是long,占用8个字节,int k[5]中都是int类型,仍然是占用4个字节的，然后union的字节数必须是占用字节最多的成员的字节的倍数,而且需要能够容纳其他的成员,为了要容纳k(20个字节),就必须要保证是8的倍数的同时还要大于20个字节,所以是24个字节。

引申：位域(大疆笔试题)

C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”( bit field) 。利用位段能够用较少的位数存储数据。一个位段必须存储在同一存储单元中，不能跨两个单元。如果第一个单元空间不能容纳下一个位段，则该空间不用，而从下一个单元起存放该位段。

1.位段声明和结构体类似

2.位段的成员必须是int、unsigned int、signed int

3.位段的成员名后边有一个冒号和一个数字

1. typedef struct_data{ 
2.    char m:3; 
3.    char n:5; 
4.    short s; 
5.      
6.    union{ 
7.    int a; 
8.    char b; 
9.    }; 
10.      
11.    int h; 
12. }_attribute_((packed)) data_t; 

答案12

m和n一起，刚好占用一个字节内存，因为后面是short类型变量，所以在short s之前，应该补一个字节。所以m和n其实是占了两个字节的，然后是short两个个字节，加起来就4个字节，然后联合体占了四个字节，总共8个字节了，最后int h占了四个字节，就是12个字节了

attribute((packed)) 取消对齐

GNU C的一大特色就是__attribute__机制。__attribute__可以设置函数属性(Function Attribute)、变量属性(Variable Attribute)和类型属性(Type Attribute)。

__attribute__书写特征是：__attribute__前后都有两个下划线，并且后面会紧跟一对括弧，括弧里面是相应的__attribute__参数。

跨平台通信时用到。不同平台内存对齐方式不同。如果使用结构体进行平台间的通信，会有问题。例如，发送消息的平台上，结构体为24字节，接受消息的平台上，此结构体为32字节(只是随便举个例子)，那么每个变量对应的值就不对了。

不同框架的处理器对齐方式会有不同，这个时候不指定对齐的话，会产生错误结果

12、inline函数

在C语言中，如果一些函数被频繁调用，不断地有函数入栈，即函数栈，会造成栈空间或栈内存的大量消耗。为了解决这个问题，特别的引入了inline修饰符，表示为内联函数。

大多数的机器上，调用函数都要做很多工作：调用前要先保存寄存器，并在返回时恢复，复制实参，程序还必须转向一个新位置执行C++中支持内联函数，其目的是为了提高函数的执行效率，用关键字 inline 放在函数定义(注意是定义而非声明)的前面即可将函数指定为内联函数，内联函数通常就是将它在程序中的每个调用点上“内联地”展开。

内联是以代码膨胀(复制)为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。

13、内存四区，什么变量分别存储在什么区域，堆上还是栈上。

文字常量区，叫.rodata，不可以改变，改变会导致段错误

1. int a0=1; 
2. static int a1; 
3. const static a2=0; 
4. extern int a3; 
5.  
6. void fun(void) 
7. { 
8.  int a4; 
9.  volatile int a5; 
10.  return; 
11. } 

a0 ：全局初始化变量;生命周期为整个程序运行期间;作用域为所有文件;存储位置为data段。

a1 ：全局静态未初始化变量;生命周期为整个程序运行期间;作用域为当前文件;储存位置为BSS段。

a2 ：全局静态变量

a3 ：全局初始化变量;其他同a0。

a4 ：局部变量;生命周期为fun函数运行期间;作用域为fun函数内部;储存位置为栈。

a5 ：局部易变变量;

14、使用32位编译情况下，给出判断所使用机器大小端的方法。

联合体方法判断方法：利用union结构体的从低地址开始存，且同一时间内只有一个成员占有内存的特性。大端储存符合阅读习惯。联合体占用内存是最大的那个，和结构体不一样。

a和c公用同一片内存区域，所以更改c，必然会影响a的数据

1. #include<stdio.h> 
2.  
3. int main(){ 
4.   union w 
5.   { 
6.       int a; 
7.       char b; 
8.   }c; 
9.   c.a = 1; 
10.   if(c.b == 1) 
11.    printf("小端存储\n"); 
12.   else 
13.    printf("大端存储\n"); 
14.  return 0; 
15. } 

指针方法

通过将int强制类型转换成char单字节，p指向a的起始字节(低字节)

1. #include <stdio.h> 
2. int main () 
3. { 
4.     int a = 1; 
5.     char *p = (char *)&a; 
6.     if(*p == 1) 
7.     { 
8.         printf("小端存储\n"); 
9.     } 
10.     else 
11.     { 
12.         printf("大端存储\n"); 
13.     } 
14.     return 0; 
15. } 

15、用变量a给出下面的定义

1. a) 一个整型数； 
2. b）一个指向整型数的指针； 
3. c）一个指向指针的指针，它指向的指针是指向一个整型数； 
4. d）一个有10个整型的数组； 
5. e）一个有10个指针的数组，该指针是指向一个整型数； 
6. f）一个指向有10个整型数数组的指针； 
7. g）一个指向函数的指针，该函数有一个整型参数并返回一个整型数； 
8. h）一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数 
9. 答案： 
10. a)int a 
11. b)int *a; 
12. c)int **a; 
13. d)int a[10]; 
14. e)int *a [10]; 
15. f) int a[10], *p=a; 
16. g)int (*a)(int) 
17. h) int( *a[10])(int) 

16、与或非，异或。运算符优先级

sum=a&b<

其中a=3,b=5,c=4(先加再移位再&再异或)答案4