最近收集了许多嵌软的面试题，内容都是在很多文章中剪下来的！

目录

1.预处理

预处理器指令#define

用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

预处理器标识#error

预处理器标识#pragma

#pragma pack：改变编译器的对齐方式

#pragma message：在预处理过程中输出一些有用的提示信息

#pragma warning：允许选择性地修改编译器警告信息。

2.goto用法

3.用变量a给出下面的定义

4.关键字static的作用是什么？

5.关键字const是什么含意？

6.关键字volatile有什么含意？并给出三个不同的例子。

7.对变量或寄存器进行位操作

8.访问某特定的内存位置

9._interrupt关键字定义了一个中断服务子程序(ISR)，请评论一下这段代码。

10.下面的代码输出是什么，为什么？

11.Typedef声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子。

12.某32位系统下, C++程序，请计算sizeof 的值.

13.已知结构体类型定义如下：

14.请写出判断程序栈增长方向的程序

15.printf函数在性能上存在着一些缺点，请描述。

---

1.预处理

预处理器指令#define

用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

#define SECONDS_PER_YEAR         (60 * 60 * 24 * 365)UL

宏定义需注意：

宏不以分号结束。

学会让预处理器做运算，它运算常数比你快n倍。

宏定义相当于文本替换，不加括号可能会影响前后运算顺序，一般都加括号。

UL代表unsigned long，明确常量类型以确保使用时不会发生意外的类型转换。

写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

#define MIN(A,B)         ( (A) <= (B)? (A) :(B) )

这里用到三重条件操作符，使得代码简洁。

预处理器标识#error

预处理器表示#error的目的是在预处理阶段中生成编译错误信息。当编译器遇到#error指令时，会生成一个由程序员定义的错误信息，并且终止编译过程。

用法：#error  "ERROR!"

预处理器标识#pragma

#pragma pack：改变编译器的对齐方式

#pragma pack(n)         // 指定按n字节对齐
#pragma pack()          // 取消自定义字节对齐

#pragma message：在预处理过程中输出一些有用的提示信息

#pragma message("HELLO!")

#pragma warning：允许选择性地修改编译器警告信息。

#pragma warning( disable : 4507 34 ; once : 4385 ; error : 164 )
// 等价于
#pragma warning( disable : 4507 34 )  // 不显示4507和34号警告信息
#pragma warning( once : 4385 )        // 4385号警告信息仅报告一次
#pragma warning( error: 164 )         // 把164号警告信息作为一个错误信息

2.goto用法

loop:

        ...

goto loop;

int main()
{
    int i=1, j=0;
    Start:
        i++; 
    while(j<99)  
    {
        goto start;
        j++;
    }
    return i;
}

3.用变量a给出下面的定义

a) 一个整型数 int  a;

b) 一个指向整型数的指针 int  *a;

c) 一个指向指针的指针，它指向的指针是指向一个整型数 int  **a;

d) 一个有10个整型数的数组 int  a[10];

e) 一个有10个指针的数组，该指针是指向一个整型数 int  *a[10];

f) 一个指向有10个整型数数组的指针 int  (*a)[10];

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数 int  (*a)(int);

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数 int  (*a[10])(int);

在这里值得注意的是：

指向整形数表明的是：(int *) 一起用。括号可省略。

在第c项中，加上括号为：(((int *)*)a);括号可省略。

在第f项中，加上了括号，使得默认的括号失去了效果，指向的是数组。第g项类同。

4.关键字static的作用是什么？

修饰局部变量、全局变量和函数。static变量和static函数都存储在静态存储区，生命周期为整个程序运行结束。普通局部变量存储于堆栈中，使用完毕会立即释放。

1）对于局部变量（在函数体内定义的静态变量），初次定义时必须初始化，且只能初始化一次（若不初始化，自动赋初值），该函数在被调用过程中维持其静态变量的值不变。在函数退出时，静态存储变量依然被保存在内存中。举个例子。

void test()    //函数体
{
    //第一次调用test()时定义静态变量a且初始化一次
    //第二次调用test()时，静态变量a已经存在于静态存储器，忽略初始化工作
    static int a = 0; 
    printf("%d", a);
    a++;
}

int main()
{
    test(); // 第一次调用，输出 a = 0
    test(); // 第二次调用，输出 a = 1
    return 0;
}

2）对于全局静态变量，仅对当前文件可见（限定作用域），其他文件不可访问。而普通的全局变量对整个工程可见，其他文件可以使用extern关键字外部声明或引入头文件的形式直接使用。

3）对于静态函数，仅对当前文件可见（限定作用域），其他文件不可访问。而普通的函数，可以在另一个文件中直接引用，甚至不需要extern来声明。

5.关键字const是什么含意？

const：只读，存储于静态存储区。

没有使用到指针时，const int a和int const a等同，代表a是一个常整形数。

指针常量和常量指针的记忆点：const 和 *，哪个最前就先读那个，哪个最前就不能改变那个。

int const *a;              //a是一个指向常整型数的指针，常量指针（const修饰的是*a，表示值不变，地址可变）

int * const a;            //a是一个指向整型数的常指针，指针常量（const修饰的是a，表示地址不变，值可变）

int const * const a ; //a是一个指向常整型数的常指针（上面两种情况兼得，表示只读，其地址以及地址中的值都不可改变，和const int a和int const a等同）

使用时需要注意指针常量和常量指针，它们的意思是不同的，很多初学者一开始都没有去区分这个区别，实际很重要。

6.关键字volatile有什么含意？并给出三个不同的例子。

volatile英文意思为，不稳定的。volatile变量是告诉编译器该变量可能会被意外地修改，因此不要对volatile变量进行优化。

规则：

每次使用volatile变量时，都会从内存中读取该变量的值；

每次更改volatile变量时，会立即写入到内存中而不是缓存中。

下面是volatile变量的几个例子：

1). 访问硬件寄存器时需使用该关键字。使用该关键字确保编译器不会对该变量进行优化（优化即无操作，一直都是旧值），每次访问都需要直接从寄存器中读取或往寄存器写入数据。保证数据的及时准确性。

volatile uint32_t *hardwareRegister = (volatile uint32_t*)0x40000000;

2). 信号处理时需使用该关键字。当使用信号处理函数处理系统的信号时，涉及到修改全局状态变量，为了确保能够正确地更新这些变量，需要使用该关键字。

volatile sig_atomic_t signalFlag = 0;

3). 多线程共享变量需使用该关键字。在多线程程序中，一个变量可能被多个线程同时访问和修改。在这种情况下，将这个变量声明为volatile可以确保每次都从内存中读取或写入，而不是使用缓存的值，避免出现并发访问的问题。

volatile int sharedVariable = 0;

一个参数既可以是const还可以是volatile吗？

可以。比如只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

一个指针可以是volatile吗？解释为什么。

可以。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。

下面的函数有什么错误：

int square(volatile int *ptr)
{
        return ptr*ptr;
}这段代码的目的是用来返回指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr)
{
    int a,b;
    a = *ptr;
    b = *ptr;
    return a*b;
}

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr)
{
    int a;
    a = *ptr;
    return a*a;
}

7.对变量或寄存器进行位操作

给定一个整型变量a,写两段代码，第一个设置a的bit3，第二个清除a的bit3，在以上两个操作中，要保持其他位不变。

第一个：a|= 0x1<<3;

第二个：a&=~0x1<<3;

需要注意的是，这两个操作在对寄存器直接进行位操作很常用，这种用法也比较固定且常用。

8.访问某特定的内存位置

在某工程中，要求设置一绝对地址为0x67a9的整形变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。

// 第一种
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa66;

// 第二种
*(int*  const)(0x67a9) = 0xaa66;

需要注意的是，尽量用第二条，因为在很多工程中对寄存器的定义都用到类似的结构，使得代码简洁。(int * const)代表返回一个整数型的只读指针变量，地址不变。括号前面的*号代表进行指针操作，即对指针变量赋值。

9._interrupt关键字定义了一个中断服务子程序(ISR)，请评论一下这段代码。

__interrupt double computer_area(double radius)
{
    double area = PI * radius * radius;
    printf("Area = %f", area);
    return area;
}

ISR特点：不传参，没返回值，并且做到处理时间短而有效率。

在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。

此外，ISR应该是短而有效率的，在ISR中做浮点运算和输出打印是不明智的。printf()经常有重入和性能上的问题。

10.下面的代码输出是什么，为什么？

void foo(void)
{
    unsigned int a = 6;
    int b = -20;
    (a+b > 6)?puts(“>6”):puts(“<6”)；
}

答案是>6，有符号和无符号在进行运算的时候会进行隐式类型转换，将有符号转换为无符号。

有一种说法就是，在进行不同类型的运算时，变量总是从小字节往大字节隐式类型转换。

11.Typedef声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子。

#define dPS struct s *;

Typedef struct s * tPS;

以上两种情况的意图都是要定义dPS和tPS作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
答案是：typedef更好。

预处理的工作是替换，不做正确性检查；而typedef编译时会做类型检查，适用于结构体。

思考下面的例子：

dPS p1,p2;

tPS p3,p4;

第一个扩展为：Struct s *p1, p2;

第二个扩展为：Struct s *p3, *p4;

上面的代码定义p1为一个指向Struct s类型的指针变量，p2为一个Struct s类型的对象，这也许不是你想要的。

第二个例子正确地定义了p3 和p4 为一个指向Struct s类型的指针变量。当p1 = &p2时，相当于把p2的地址赋值给p1，可以通过p1->x去访问p2对象的成员。

12.某32位系统下, C++程序，请计算sizeof 的值.

void Foo_1 ( char str[100])
{
    cout<<"Foo_1:"<<sizeof( str )<<endl; 
}

char str_1[] = "abcdef";
char *p = str_1 ;
cout<<sizeof(str_1); // 7 加了一个‘\0’
cout<<sizeof(p);     // 4，这里有指针，p代表地址，32位代表4字节。

char *str_2 = "abcdef";
char *q = str_2 ;
cout<<sizeof(str_2); // 4
cout<<sizeof(q);     // 4

char str_3[] = {'a','b','c','d','e','f'};
char *l = str_3 ;
cout<<sizeof(str_3);         // 6
cout<<"l:"<<sizeof(l)<<endl; // 4

char *str_3 = {'a','b','c','d','e','f'}; //编译错误
char *str_3 = {'a'};                     //编译错误

Foo_1(str_1);  // 4
Foo_1(str_2);  // 4
Foo_1(str_3);  // 4
void *k = malloc( 100 );
cout<<sizeof(k); // 4

附：数组做形参，则退化为指针；数组的引用做形参，则数组的大小也成为形参类型的一部分。

13.已知结构体类型定义如下：

#pragma pack(1) //以1字节对齐
struct node_t{
    char A;
    int b;
    int c;
};注：这里的偏移量指的是相对于结构体起始位置的偏移量。请用代码表达。

struct node_t node; 
(unsigned long)(&node.c)-(unsigned long)(&node);

sizeof(node)=12，这里需要了解结构体对齐规则，有感兴趣的可以去学习一下。转化为无符号长整形进行计算（因为首地址占4个字节，且第一为符号位，若两个地址相加，无符号整形表示结果，显然无法满足。所以一般转化为长整形，这样会更安全一点。）

14.请写出判断程序栈增长方向的程序

栈是从大内存存储地址到小内存存储地址增长，而堆是从小到大。

void stackDirection(void)
{
    static char *addr = NULL;
    char dummy;

    if(addr == NULL)      //第一次进入函数
    {
        addr = &dummy;    //dummy第一次的地址赋予给addr。
        stackDirection(); //递归调用，让dummy两次被定义，并一先一后入栈
    }else                 //第二次进入函数
    {       
        //addr相当于第一次&dummy，&dummy为第二次的地址。        
        if (addr > &dummy)    
            printf("栈:向下增长");
        else                  
            printf("堆:向上增长");           
    }
}

15.printf函数在性能上存在着一些缺点，请描述。

内存分配：printf函数在进行格式化输出时，需要动态分配内存来存储生成的格式化字符串。这种内存分配和释放的操作会带来一定的性能开销，特别是在频繁调用printf函数时，可能会导致内存碎片问题。

字符串解析：printf函数对于格式化字符串进行解析和处理时需要一定的时间。由于其灵活的格式化功能，需要进行复杂的解析操作，这会对性能产生一定影响。

系统调用：printf函数在将格式化字符串输出到屏幕或文件时，通常会调用系统函数来完成实际的输出操作。这涉及到用户态和内核态的切换，会引入额外的开销。

可变参数列表：printf函数使用可变参数列表来接收不定数量的参数，这种机制在一定程度上会影响性能，尤其在参数较多或者参数类型不确定的情况下。

缓冲区刷新：printf输出的内容通常首先被写入到输出缓冲区中，当缓冲区满了或者遇到换行符等情况时才会刷新缓冲区并将内容输出到屏幕或文件中。这种缓冲区机制也可能会影响性能。