（1）公司简介：做打印机设备、项目涉及到操作系统
（2）面试内容：笔试题+技术面试
//32位单片机c语言程序
typedef struct{
int a;
char b;
char c;
}str1;
typedef struct{
char a;
int b;
char c;
}str2;
void function(char src_buf[100])
{
char str[]="hello world";
char buf[100];
char *p=str;
int n=10;
char k=10;
printf("1:sizeof(str)=%d\r\n",sizeof(str));
printf("2:strlen(str)=%d\r\n",strlen(str));
strcpy(buf,str);
printf("3:sizeof(buf)=%d\r\n",sizeof(buf));
printf("4:strlen(buf)=%d\r\n",strlen(buf));
printf("5:sizeof(p)=%d\r\n",sizeof(p));
printf("6:sizeof(n)=%d\r\n",sizeof(n));
printf("7:sizeof(k)=%d\r\n",sizeof(k));
printf("8:sizeof(src_buf)=%d\r\n",sizeof(src_buf));
printf("9:sizeof(str1)=%d\r\n",sizeof(str1));
printf("10:sizeof(str2)=%d\r\n",sizeof(str2));
}
void main()
{
char ram_buf[100];
function(ram_buf[100]);
}1.sizeof(str):计算字符串大小，要包含终止符“\0”；比如“空格”、“-”、“~”也算字符
2.strlen(str):计算字符串长度，不包含终止符“\0”
3.sizeof(buf):buf是长度为100的数组
4.strlen(buf):str内容复制给了buf，所以buf内容是“hello world\0”。只计算长度还是11
5.p是字符指针char *,在32为系统中占用4字节
6.n 为char类型，占用1字节
7.k 为int类型，占用4字节
8.src_buf是char类型的数组指针，在32为系统中占用4字节
9.结构体对齐原则
第一个成员在于结构体变量偏移量为0的地址处
结构体总大小为最大数的整数倍
比如str1
第1个成员是int，占用4字节
第2个成员char，占用1字节
第3个成员char，占用1字节
对齐后：4+4=8
比如str2
第1个成员是char，占用4字节,因为下一个是int
第2个成员int，占用4字节，
第3个成员char，占用4字节，补全字节，要整数倍
对齐后：4+4+4=12
2.下面两个tor 循环，功能完全相同，即在运行过程中，条件condition 不会发生变化,请判断这两个for循环的优缺点。(10分)
// 第一个
for (i=0; i<N; i++){
if(condition){
DoSomething();
} else {
DoOtherthing();
}
/ /第二个
if(condition){
for (i=0; i<N; i++){DoSomething();
} else {
for (i=0; i<N; i++){DoOtherthing();
}
问题1:这两个 for 循环，哪个的时间效率更高?即哪个运行得更快?写出时间效率高的原因。(5分)
第2个循环
优点：条件判断只执行一次；循环体内无条件分支，减少指令
缺点：重复编写两个相似循环体，占用空间大
问题 2:这两个for 循环，哪个的空间效率高?即哪个占用较少的程序存储空间?写出空间效率高的原因。(5分)
第1个循环
优点：代码简洁，无冗余循环体
缺点：每次循环都要执行条件判断
3.
void main()
{
char a=0x06;
char b=0x03;
printf("a&&b=%d\r\n",a&&b);
printf("a&b=%d\r\n",a&b);
printf("a||b=%d\r\n",a||b);
printf("a|b=%d\r\n",a|b);
printf("a^b=%d\r\n",a^b);
}注意区别：
|（按位或运算符）：对两个操作数的对应二进制位进行逻辑或运算。只要对应的两个二进制位中有一个为 1，则该位的结果为 1；只有当两个二进制位都为 0 时，结果才为 0。
&（按位与运算符）：对两个操作数的对应二进制位进行逻辑与运算。只有当对应的两个二进制位都为 1 时，该位的结果才为 1；否则结果为 0。
&&（逻辑与运算符）：对两个操作数进行逻辑与运算。只有当两个操作数都为真（非 0）时，结果才为真（1）；只要有一个操作数为假（0），结果就为假（0）。并且 && 具有短路特性，即如果第一个操作数为假，则不会再计算第二个操作数。
||（逻辑或运算符）：对两个操作数进行逻辑或运算。只要有一个操作数为真（非 0），结果就为真（1）；只有当两个操作数都为假（0）时，结果才为假（0）。|| 也具有短路特性，即如果第一个操作数为真，则不会再计算第二个操作数
//-----------------------------------------------------------------------------------------------------
所以结果为
4.要求编写strcpy()函数原型
(1)不调用C++/C的字符串库函数,请编写函数 strcpy
char *strcpy(char *strDest, const char *strSrc)
{
if(strDest == NULL || strSrc == NULL)return;
Char *ret = strDest;
While ((*strDest++ = *strSrc++) != ‘\0’);
Return ret;
}
(2)strcpy能把strSrc的内容复制到strDest,为什么还要char * 类型的返回值?
为了实现连续赋值操作,如:
Int strcpy(str1, strcpy(str2, str3));
5.
二：
1.
- %d ：用于输出十进制整数。
- %u：用于输出无符号十进制整数。
- %f：用于输出浮点数。
- %s：用于输出字符串。
- %c：用于输出字符。
- %p：用于输出指针。
(1)char：1 字节
(2)short：2 字节 相当与short int
(3)int：4 字节
(4)long：4 字节（32位机），8 字节（64位机） 相当于long int
(5)long long：8 字节
(6)float：4 字节
(7)double：8 字节
void main()
{
char a,a1,a2,a3,a4;
int b,b1,b2,b3;
short int c;
long int d;
// long long int e;
char *f;
int *g;
short int *h;
long int *i;
// long long int *j;
char k[20]="98765432";
b1=3;
b2=0;
b3=6;
f=&k[2];
printf("f=%p\r\n",f);
printf("f=%c\r\n",*f);
//-----++f 使用变量前自增----------
//-----f++ 使用变量后自增----------
/*
1.如果 *和++/--都在指针变量的左边，结合方向为从右到左；
2.如果 *和++/--分别在指针变量的左边/右边，结合方向为从左到右；
3.有括号的先执行括号的表达式，然后在执行规律 1 或者规律 2；
*/
a1=(*f)++; //
printf("f1=%p\r\n",f); //f1地址=f地址=0019FEE6
printf("a1=%c\r\n",a1); //*f等于7，所以a1=7;
//printf("*f=%c\r\n",*f); //使用后自增,所以*f等于8
a2=*f++; //等于a2=(*f)++,先计算*f,f地址自增1
printf("f2=%p\r\n",f); //地址0019FEE7
printf("a2=%c\r\n",a2);//*f等于8，所以a2=8
printf("*f=%c\r\n",*f); //取地址0019FEE7的值，*f等于6
a3=*++f; //等于*(++f)，f地址自增1,再计算*(f++)
printf("f3=%p\r\n",f); //地址0019FEE8
printf("a3=%c\r\n",a3);//取地址0019FEE8的值，所以a3=5
a4=*(f++); //f地址自增1,再计算*f
printf("f4=%p\r\n",f); //地址0019FEE9
printf("a4=%c\r\n",a4);//取地址0019FEE8的值，所以a4=5
printf("out1=%d\r\n",sizeof(a));
printf("out2=%d\r\n",sizeof(b));
printf("out3=%d\r\n",sizeof(c));
printf("out4=%d\r\n",sizeof(d));
// printf("out5=%d\r\n",sizeof(e));
printf("out6=%d\r\n",sizeof(f));
printf("out7=%d\r\n",sizeof(g));
printf("out8=%d\r\n",sizeof(h));
printf("out9=%d\r\n",sizeof(i));
// printf("out10=%d\r\n",sizeof(j));
printf("out11=%d\r\n",sizeof(k));
printf("out12=%d\r\n",strlen(k));
printf("out13=%d\r\n",sizeof("adcdefg"));
printf("out14=%d\r\n",strlen("adcdefg"));
printf("out15=%c\r\n",a1);
printf("out16=%c\r\n",a2);
printf("out17=%c\r\n",a3);
printf("out18=%c\r\n",a4);
}
2.#ifdef #endif作用
防止头文件重复包含
条件编译：可以根据不同的编译环境或条件选择性地编译代码段，便于调试和功能开关
3.const作用
定义常量：使用const可以定义一个常量值，确保该值在初始化后不会被修改。这有助于防止程序中出现意外的数据变更，提高代码的可读性和安全性。
提高代码可读性：当看到用const定义的变量时，可以立刻知道这个变量的值是不会改变的，这使得代码更易读、易维护。
优化性能：在某些编程语言中，编译器可以利用const变量的不变性进行优化，从而提高程序的运行效率。
4.有关内存的思考题
（1）、
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}请问运行Test 函数会有什么样的结果？
答：程序崩溃。
因为GetMemory 并不能传递动态内存，
Test 函数中的 str 一直都是 NULL。
strcpy(str, "hello world");将使程序崩
溃。
（2）、
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}请问运行Test 函数会有什么样的结果？
答：可能是乱码。
因为GetMemory 返回的是指向“栈内存”
的指针，该指针的地址不是 NULL，但其原
现的内容已经被清除，新内容不可知。
（3）、
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}请问运行Test 函数会有什么样的结果？
答：（1）能够输出hello；（2）内存泄漏
（4）、
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
}请问运行Test 函数会有什么样的结果？
答：篡改动态内存区的内容，后果难以预
料，非常危险。
因为free(str);之后，str 成为野指针，
if(str != NULL)语句不起作用。
其他：为啥离职？项目难点？怎么分析需求？