华为 中兴 海康嵌入式软件工程师面试题

去年毕业时候为了找工作刷了不少笔试题，各种大公司小公司只要是网上能搜到的面试题几乎都看了一遍，如同当年高考刷题一样。想到现在又是一年毕业季，给学弟学妹们总结一些面试题。

华为

第1题: 考查对volatile关键字的认识
#include
static jmp_buf buf;

main()
{
volatile int b;
b =3;

if(setjmp(buf)!=0)
{
printf("%d ", b);
exit(0);
}
b=5;
longjmp(buf , 1);
}
请问，这段程序的输出是 b
(a) 3
(b) 5
© 0
(d) 以上均不是

第2题:考查类型转换
main()
{
struct node
{
int a;
int b;
int c;
};
struct node s= { 3, 5,6 };
struct node *pt = &s;
printf("%d" , (int)pt);

}
这段程序的输出是: a
(a) 3
(b) 5
© 6
(d) 7

第3题:考查递归调用
int foo ( int x , int n)　
{
int val;
val =1;

if (n>0)
{
if (n%2 == 1) val = val *x;

val = val * foo(x*x , n/2);

}
return val;
}
这段代码对x和n完成什么样的功能(操作)?
(a) x^n (x的n次幂)
(b) x*n(x与n的乘积)
© n^x(n的x次幂)
(d) 以上均不是

第4题:考查指针,这道题只适合于那些特别细心且对指针和数组有深入理解的人
main()
{
int a[5] = {1,2,3,4,5};
int ptr = (int)(&a+1);

printf("%d %d" , *(a+1), *(ptr-1) );

}
这段程序的输出是:

(a) 2 2
(b) 2 1
© 2 5
(d) 以上均不是

第5题:考查多维数组与指针
void foo(int [][3] );

main()
{
int a [3][3]= { { 1,2,3} , { 4,5,6},{7,8,9}};
foo(a);
printf("%d" , a[2][1]);
}

void foo( int b[][3])
{
++ b;
b[1][1] =9;
}
这段程序的输出是:

(a) 8
(b) 9
© 7
(d)以上均不对

第6题目:考查逗号表达式
main()
{
int a, b,c, d;
a=3;
b=5;
c=a,b;
d=(a,b);

printf(“c=%d” ,c);
printf(“d=%d” ,d);

}
这段程序的输出是:

(a) c=3 d=3
(b) c=5 d=3
© c=3 d=5
(d) c=5 d=5

第7题:考查指针数组
main()
{
int a[][3] = { 1,2,3 ,4,5,6};
int (*ptr)[3] =a;

printf("%d %d " ,(*ptr)[1], (*ptr)[2] );

++ptr;
printf("%d %d" ,(*ptr)[1], (*ptr)[2] );
}
这段程序的输出是:

(a) 2 3 5 6
(b) 2 3 4 5
© 4 5 0 0
(d) 以上均不对

第8题:考查函数指针
int *f1(void)
{
int x =10;
return(&x);
}

int f2(void)
{
intptr;
*ptr =10;
return ptr;
}

int *f3(void)
{
int ptr;
ptr=(int) malloc(sizeof(int));
return ptr;
}
上面这3个函数哪一个最可能引起指针方面的问题

(a) 只有 f3
(b) 只有f1 and f3
© 只有f1 and f2
(d) f1 , f2 ,f3

第9题:考查自加操作(++)
main()
{
int i=3;
int j;

j = sizeof(++i+ ++i);

printf(“i=%d j=%d”, i ,j);
}
这段程序的输出是:

(a) i=4 j=2
(b) i=3 j=2
© i=3 j=4
(d) i=3 j=6

第10题:考查形式参数，实际参数，指针和数组
void f1(int *, int);
void f2(int *, int);
void(*p[2]) ( int *, int);

main()
{
int a;
int b;

p[0] = f1;
p[1] = f2;
a=3;
b=5;

p[0](&a , b);
printf("%d\t %d\t" , a ,b);

p[1](&a , b);
printf("%d\t %d\t" , a ,b);
}

void f1( int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
}

void f2( int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
}
这段程序的输出是:

(a) 5 5 5 5
(b) 3 5 3 5
© 5 3 5 3
(d) 3 3 3 3

第11题:考查自减操作(–)
void e(int );

main()
{
int a;
a=3;
e(a);
}

void e(int n)
{
if(n>0)
{
e(–n);
printf("%d" , n);
e(–n);
}
}
这段程序的输出是:

(a) 0 1 2 0
(b) 0 1 2 1
© 1 2 0 1
(d) 0 2 1 1

第12题:考查typedef类型定义,函数指针
typedef int (test) ( float * , float)
test tmp;
tmp 的类型是

(a) 函数的指针，该函数以 两个指向浮点数(float)的指针(pointer)作为参数(arguments)
Pointer to function of having two arguments that is pointer to float
(b) 整型
© 函数的指针，该函数以 两个指向浮点数(float)的指针(pointer)作为参数(arguments),并且函数的返回值类型是整型
Pointer to function having two argument that is pointer to float and return int
(d) 以上都不是

第13题:数组与指针的区别与联系
main()
{
char p;
char buf[10] ={ 1,2,3,4,5,6,9,8};
p = (buf+1)[5];
printf("%d" , p);
}
这段程序的输出是:

(a) 5
(b) 6
© 9
(d) 以上都不对

第14题: 考查指针数组的指针
Void f(char**);

main()
{
char * argv[] = { “ab” ,“cd” , “ef” ,“gh”, “ij” ,“kl” };
f( argv );
}

void f( char *p )
{
char t;

t= (p+= sizeof(int))[-1];

printf( “%s” , t);
}
这段程序的输出是:

(a) ab
(b) cd
© ef
(d) gh

第15题:此题考查的是C的变长参数,就像标准函数库里printf()那样,这个话题一般国内大学课堂是不会讲到的,不会也情有可原呵呵,
#include
int ripple ( int , …);

main()
{
int num;
num = ripple ( 3, 5,7);
printf( " %d" , num);
}

int ripple (int n, …)
{
int i , j;
int k;
va_list p;

k= 0;
j = 1;
va_start( p , n);

for (; j {
i = va_arg( p , int);
for (; i; i &=i-1 )
++k;
}
return k;
}
这段程序的输出是:

(a) 7
(b) 6
© 5
(d) 3

第16题:考查静态变量的知识
int counter (int i)
{
static int count =0;
count = count +i;
return (count );
}
main()
{
int i , j;

for (i=0; i <=5; i++)
j = counter(i);
}
本程序执行到最后,j的值是:

(a) 10
(b) 15
© 6
(d) 7

详细参考答案

第1题: (b)
volatile字面意思是易于挥发的。这个关键字来描述一个变量时，意味着 给该变量赋值(写入)之后，马上再读取，写入的值与读取的值可能不一样,所以说它"容易挥发"的。
这是因为这个变量可能一个寄存器，直接与外部设备相连，你写入之后，该寄存器也有可能被外部设备的写操作所改变;或者，该变量被一个中断程序，或另一个进程
改变了.
volatile 不会被编译器优化影响，在longjump 后,它的值 是后面假定的变量值,b最后的值是5,所以5被打印出来.

setjmp : 设置非局部跳转 /* setjmp.h*/

Stores context information such as register values so that the lomgjmp function can return control to the statement following the one calling setjmp.Returns 0 when it is initially called.

Lonjjmp: 执行一个非局部跳转 /* setjmp.h*/

Transfers control to the statement where the call to setjmp (which initialized buf) was made. Execution continues at this point as if longjmp cannot return the value 0.A nonvolatile automatic variable might be changed by a call to longjmp.When you use setjmp and longjmp, the only automatic variables guaranteed to remain valid are those declared volatile.

Note: Test program without volatile qualifier (result may very)

更详细介绍，请参阅 C语言的setjmp和longjmp

第2题: (a)
结构题的成员在内存中的地址是按照他们定义的位置顺序依次增长的。如果一个结构体的指针被看成 它的第一个成员的指针,那么该指针的确指向第一个成员

第3题: (a)
此题目较难.

这个程序的非递归版本
int what ( int x , int n)
{
int val;
int product;
product =1;
val =x;

while(n>0)
{
if (n%2 == 1)
product = productval; /如果是奇数次幂, x(val)
要先乘上一次,;
偶数次幂,最后返回时才会到这里
乘以1/
val = val val;
n = n/2;
}
return product;
}
/* 用二元复乘策略 */
算法描述
(while n>0)
{
if next most significant binary digit of n( power) is one
then multiply accumulated product by current val ,
reduce n(power) sequence by a factor of two using integer division .
get next val by multiply current value of itself
}

第4题: ©
a的类型是一个整型数组,它有5个成员
&a的类型是一个整型数组的指针
所以&a + 1指向的地方等同于 a[6]

所以*(a+1) 等同于a[1]
ptr等同 a[6], ptr-1就等同与a[5]

第5题: (b)

题目自身就给了足够的提示
b[0][0] = 4
b[1][0] = 7

第6题: ©
考查逗号表达式,逗号表达式的优先级是很低的，比 赋值(=)的优先级 低. 逗号表达式的值就是最后一个元素的值
逗号表达式的还有一个作用就是分割函数的参数列表…

E1, E2, …, En
上面这个表示式的左右是,E1, E2,… En的值被分别计算出来，En计算出来的结构赋给整个逗号表达式
c=a,b; / yields c=a /
d=(a,b); /* d =b */

第7题: (a)

ptr是一个数组的指针，该数组有3个int成员

第8题: ©
f1显然有问题，它返回一个局部变量的指针，局部变量是保存在stack中的,退出函数后，局部变量就销毁了，保留其指针没有意义，因为其指向的stack空间可能被其他变量覆盖了
f2也有问题, ptr是局部变量，未初始化，它的值是未知的，ptr不知道指向哪里了，直接给ptr赋值可能会覆盖重要的系统变量，这就是通常说的野指针的一种

第9题: (b)
sizeof 操作符给出其操作数需要占用的空间大小，它是在编译时就可确定的，所以其操作数即使是一个表达式，也不需要在运行时进行计算.( ++i + ++ i )是不会执行的，所以
i 的值还是3

第10题: (a)
很显然选a.
f1交换*p 和 q的值，f1执行完后, *p 和 q的值的确交换了, 但 q的改变不会影响到 b的改变, *p 实际上就是 a
所以执行f1后, a=b=5
这道题考查的知识范围很广,包括typedef自定义类型,函数指针,指针数组
void(*p[ 2 ]) ( int *, int);
定义了一个函数指针的数组p,p有两个指针元素. 元素是函数的指针，函数指针指向的函数是一个带2个参数,返回void的函数，所带的两个参数是 指向整型的指针，和整型
p[ 0 ] = f1; p[ 1 ] = f2 contain address of function .function name without parenthesis represent address of function Value and address of variable is passed to function only argument that is effected is a (address is passed). Because of call by value f1, f2 can not effect b

第11题: (a)

考查–操作和递归调用,仔细分析一下就可以了

第12题: ©
建议不会的看看C专家编程
从左往有，遇到括号停下来，将第一个括号里的东西看成一个整体

第13题: ©
考查什么时候数组就是指针.对某些类型T而言，如果一个表达式是 T[] (T的数组), 这个表达式的值实际上就是指向该数组的第一个元素的指针.所以(buf+1)[5]实际上就是*(buf +6)或者buf[6]

第14题: (b)

sizeof(int)的值是2,所以p+=sizeof(int) 指向 argv[2],这点估计大家都没有什么疑问

(p+=sizeof(int))[-1] 指向 argv[1],能理解吗，因为(p+=sizeof(int))[-1] 就相当于 (p+=2)[-1] ,也就是(p+2-1)

第15题: ©
在C编译器通常提供了一系列处理可变参数的宏，以屏蔽不同的硬件平台造成的差异，增加程序的可移植性。这些宏包括va_start、 va_arg和va_end等。
采用ANSI标准形式时，参数个数可变的函数的原型声明是：
type funcname(type para1, type para2, …)
这种形式至少需要一个普通的形式参数，后面的省略号不表示省略，而是函数原型的一部分。type是函数返回值和形式参数的类型。
不同的编译器，对这个可变长参数的实现不一样 ，gcc4.x中是内置函数.
关于可变长参数,可参阅
http://www.upsdn.net/html/2004-11/26.html
http://www.upsdn.net/html/2004-11/24.html

程序分析
va_list p; /定义一个变量 ,保存 函数参数列表 的指针/
va_start( p , n); /用va_start宏 初始化 变量p,
va_start宏的第2个参数n ,
是一个固定的参数,
必须是我们自己定义的变长函数的最后一个入栈的参数
也就是调用的时候参数列表里的第1个参数/
for (; j/
{
i = va_arg( p , int); /va_arg取出当前的参数,
并认为取出的参数是一个整数(int) /
for (; i; i &=i-1 ) /判断取出的i是否为0/
++k; / 如果i不为0, k自加,
i与i-1进行与逻辑运算, 直到i 为0
这是一个技巧，下面会谈到它的功能/
}
当我们调用ripple函数时，传递给ripple函数的 参数列表的第一个参数n的值是3 .
va_start 初始化 p士气指向第一个未命名的参数(n是有名字的参数) ,也就是 is 5 (第一个).
每次对 va_arg的调用，都将返回一个参数，并且把 p 指向下一个参数.
va_arg 用一个类型名来决定返回的参数是何种类型,以及在 var_arg的内部实现中决定移动多大的距离才到达下一个 参数
(; i; i&=i-1) k++ / 计算i有多少bit被置1 */

5用二进制表示是 (101) 2
7用二进制表示 (111) 3
所以 k 返回 5(2+3),也即本题应该选c

举个例子，就很好理解了
令 i= 9 = 1001
i-1 = 1000
(i-1) +1 = i
1000
+1
1 001
因为i与i-1的最右边的那位(最低位) 肯定是不同，如果i1,i-1肯定是0，反之亦然. i & i-1 这个运算，在二相补的数字系统中，将会 消除最右边的1位
第16题: (b)
答案是 (b)
相传高斯小学一年级的时候就会做这类等比数列的题目了.这道题考查的是静态变量的知识,当每次调用完函数之后,静态变量的值不会丢失,这与栈中的临时局部变量明显不同的地方.
所以,第一次调用counter(0)之后,count =0
第二次调用 counter(1)后 count = 0+1;
第三次调用 counter(2) count = 1+2; /* count = count +i */
第四次调用 counter(3) count = 3+3;
第五次调用 counter(4) count = 6+4;
第六次调用 counter(5) count = 10+5;

中兴

面试题1：变量的声明和
定义：为变量分配地址和内存空间
声明：不分配地址。
一个变量可以在多处声明，但是定义只能有一个，加extern的变量是声明，说明此变量在其他文件已经定义。

面试题2：sizeof和strlen的区别
Sizeof是求数据类型所占空间的大小，是一个操作符，在编译时计算出结果
Srelen是求以\0结束的字符串的实际长度，是一个函数，在运行时才运算出结果

面试题3：写一个“标准”宏MIN
#define MIN(x,y) (x)>(y)?(y):(x)

面试题4：一个指针可以是volatile吗？
可以，因为指针也是一个变量，有时也有变化的不可控性，比如修改中断服务子程序中的指针时必须加volatile。

面试题5：a 和 &a 有什么区别
请写出以下代码的打印结果，主要目的是考察a和&a的区别。
#include
void main( void )
{
int a[5]={1,2,3,4,5};
int ptr=(int )(&a+1);
printf("%d,%d",(a+1),(ptr-1));
return;
}
2 和 5

面试题6：简述C、C++程序编译的内存分配情况
1.静态存储区域分配（数据段），全局变量和静态变量的分配，该内存在整个程序运行中都存在，速度快、不易出错、由系统自动分配。
2.栈区分配，函数内的局部变量以及函数的参数和返回值，该内存在函数执行的时候被分配内存在函数结束之后就释放，但是分配的内存容量有限
3.堆区分配，该内存由程序人员自己malloc分配以及free释放。如果不释放会造成内存泄漏。
面试题7：简述strcpy sprintf与mencpy的区别
Strcpy是字符串拷贝，操作对象是两个字符串
Sprintf是其他数据类型格式转化字符串，操作对象是任何数据类型
Mencpy是内存块拷贝，操作对象是可操作的两个内存地址
面试题8：链表与数组的区别
链表：由程序员自动分配任意大小的内存，并由程序员释放，每一块的地址是随机分配的，插入和删除方便，查找时比较繁琐，不存在内存越界问题
数组：连续的一块内存，由系统分配和释放，在申明时需要明确长度，适合查找不适合插入删除，存在内存越界问题。
面试题9：简述队列和栈的异同
队列：先进先出
栈：先进后出
都是线性存储结构
面试题10：编码实现直接插入排序
for(i=1; i<10i++) {
tmp = array[i];
for(j=i; j>0 && array[j-1]>tmp; j-- ){
array[j]=array[j-1];
}
array[j] = tmp;
}
面试题11：编码实现冒泡排序
for(j=0;j<10;j++)
{
for(i=0;i {
int temp;
if(ARRAY[i]>ARRAY[i+1])
{
temp=ARRAY[i+1];
ARRAY[i+1]=ARRAY[i];
ARRAY[i]=temp;
}
}
}

面试题12：编码实现直接选择排序
8 for(i=0; i 9 k = i;
10 for(j=i+1;j 11 if(array[j] < array[k]) {
12 k = j;
13 }
14 }
15 if(k != i) {
16 tmp = array[i];
17 array[i] = array[k];
18 array[k] = tmp;
19 }
20 }
面试题13：typedef和define有什么区别
#define实质是文本替换，属于C指令用于定义各种数据类 数值 字符串 函数 等定义别名，在编译器预处理的时候进行替换的
Typedef 仅限于为类型定义名称，是在编译器执行时候进行解释的
面试题14：关键字const是什么
被const修饰的变量不允许被修改，在单片机中将变量或数组 写入到flansh中，节省内存空间

面试题15：static有什么作用
修饰函数和全局变量在该模块用
修饰局部变量增加作用域变为全局变量
面试题16：extern有什么作用
Extern修饰的变量和函数使说明该变量和函数使引用其他文件中的变量和函数
面试题17：简述指针常量与常量指针区别
指针常量：定义了一个指针，该指针只能在定义的时候初始化，在之后的任何时候都不可改变，指针常量时唯一的，强调指针不可变
常量指针：定义了一个指针，该指针指向的内容不可改变，强调指向的内容不可变。
面试题18：如何避免“野指针
在定义的时候将其初始化或者指向NULL，

面试题19：用C编写一个死循环程序
While（1）
For（；；）
面试题20：编码实现某一变量某位清0或置1
清零： x&=~（ x<<1）
置1：x|=(x<<1)

面试题21：a=3,b=5,不用第三变量temp,对a和b的值进行交换
b=a+b; a = a^b;
a=b-a; b =b^a;
b=b-a a=a^b;

面试题22：宏定义的用法，看下面这个程序，求出结果
#include
#define S(a,b) a*b

int main(void)
{
int n = 3;
int m = 5;
printf("%d",S(n+m,m+n));

return 0;
}
31

面试题23：
C语言中，运算对象必须是整型数的运算符的有（B×）A
A、% B、/ C、%和/ D、*

面试题25：
以下程序执行的结果是__
#include ]
#define N 2
#define M N+1
#define NUM (M+1)*M/2
main()
{
pritf("%d",NUM);
}

海康

1、下面的C程序在Linux下使用gcc编译成功后变量k处于（C）中。× B
int j = 100;

int main(int argc, char **argv)
{
static k = 0;
int i = 0;
for (i = 0; i k += i;
}

return 0;

}

A text段
B data段
C bss段
D 栈

2、下列表达式中a的值为多少？ A
int a=(3!=2);
A 1 B 0 C 3 D 2
3、下列表达式中a的值是多少？ C × A
char test[8] = { 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08 };
int test_p = (int )test;
int a = test_p[1];
A 0x08070605
B 0x04030201
C 0x05060708
D 0x01020304
4、以下对字符串数组test赋值方式错误的是（D）。
A char test[]={‘t’,‘e’,‘s’,‘t’};
B char test[10]=“test”;
C char test[10]; strcpy(test,“test”);
D char test[10]; test=“test”;
5、设有下列语句，下列选项中对数组元素正确的引用是（A）
char a[9] = { ‘H’,‘I’,‘K’,‘V’,‘S’,‘I’,‘O’,‘N’ };
char ptr = a;
A (ptr+5)
B ptr+5
C ptr[a]
D a[ptr]
6、下面程序的输出值，正确的是（C）
#include
#include
int main()
{
int m;
unsigned int a[20];
unsigned int p;
m = 10;
p = a;
(p++) = m++;
p = m;
printf("%d %d\n", a[0], a[1]);
return 0;
}
A 11 11
B 10 10
C 10 11
D 11 10
7、下列运算的结果是多少？ C
int a = 30 + 20 % 3 * 2;
A 4
B 42
C 34
D 64
8、在C语言程序中，下列运算后n的值是多少？A × D
int n = 0;
int f = 17;
n = 4 * f % 3 + 1;
A 9
B 0
C 2
D 3
9、设有如下的宏定义，则执行语句后的输出是（C）
#define f(x) (x4)
printf("%d\n", 2 * f(5 + 3));
A 52
B 22
C 34
D 64
10、设有如下的宏定义，则执行语句后a的值是（B）。
#define TEST(a,b) ab
int a = TEST(1 + 2, 3);
A 3
B 7
C 2
D 9
11、如下哪种存储空间数据访问效率最高（A）。×D
A Flash
B 片内RAM
C 不可Cache内存
D 可Cache内存
12、以下关于信号量描述错误的为（A）
A 信号量只能在线程之间共享
B 不允许销毁一个正在等待的信号量
C 用户态使用的信号量分为POSIX信号量和SYSTEM V信号量
D 信号量有两种基本操作：V操作，信号量加1；P操作，信号量减1（如果信号量为0，则阻塞）
13、操作系统在运行过程中，不断地选择新进程运行来实现CPU的共享，但其中（A）不是引起操作系统选择新进程的直接原因。
A 有新进程进入就绪队列
B 运行进程的时间片用完
C 运行进程出错
D 运行进程要等待某一事件发生
14、Linux进程间通信方试中，如下哪一种最常用且最高效？C
A FIFO
B 消息队列
C 共享内存
D 管道
15、什么是临界区？A
A 程序中访问共享资源的片段
B 其他都不对
C 程序结束运行即将退出的地方
D 程序开始运行的地方
16、冒泡排序时间复杂度和空间复杂度分别是（B）× C
A 2n、2
B nn、2
C nn、1
D 2n、1
如果算法执行所需要的临时空间不随着某个变量n的大小而变化，即此算法空间复杂度为一个常量，可表示为 O(1)。空间复杂度比较常用的有：O(1)、O(n)、O(n²)
17、层序遍历的基本思路是：从二叉树的根节点开始，层数依次从1到n层，每层都从左儿子到右儿子遍历，依次按照层顺序遍历。下列序列都是经过层序遍历完全二叉树的结果，其中是堆的序列是（）。B
A 94、21、36、28、57、73
B 21、28、57、36、94、73
C 21、36、73、28、57、94
D 94、57、36、28、73、21
堆排序：大根堆：每个根节点大于孩子节点，小根堆：每个根节点小于孩子节点
18、以下关于队列和栈的说法不正确的是（A）。
A 队列操作中，仅有入队和出队
B 设计队列和栈，均可以采用数组和链表的方式
C 可以使用队列模拟栈的操作
D 函数调用参数环境的保存，应用的是栈的操作
19、下列数据结构可以通过任意元素找到目标元素的结构是（A）。×B
A 顺序链表
B 双链表
C 单链表
D 静态链表
20、下面不属于cache的映射方式的是（）。C
A full-associative（全关联）
B direct-mapping（直接映射）
C indirect-mapping（间接映射）
D set-associative（组相关）
21、能在Linux内核态执行的是？A ABC
A 进程调度
B 缺页异常
C 时钟中断
D 命令解释
22、在程序执行过程中，该程序的某一个函数func()中申请的static型变量V有以下哪些特性（ BD）。× AB
A V仅能被func()使用
B V存在于整个程序执行过程
C V存在于func()被调用期间
D V能被整个程序使用
23、下面关于Heap和Stack内存空间描述正确的是（ABD）。
A 程序运行过程中函数调用时参数的传递在Stack上进行
B Stack的空间由操作系统自动分配/释放
C C中的malloc函数分配的内存空间在Stack上
D Heap上的空间手动分配/释放
24、有函数fun()定义如下，在main函数调用fun函数执行过程中，使用了哪些函数参数传递方式BC
int fun(int a[], short ptr, int &c){
…
}
A 数组传递
B 指针传递
C 引用传递
D 值传递
25、以下关于进程和线程的描述正确的有（CD）BCD
A 进程切换比线程切换的开销更小
B 每个线程拥有自己的堆栈和局部变量
C 线程是程序执行的最小单位
D 进程有独立的地址空间，而线程没有
简答题
1、录像存储是DVR/NVR产品中一个非常重要的功能，客户对产品的存储能力非常看重。假设存储需求总量=通道数录像码率录像时间：已知通道数=16，各个通道的录像码率都是4Mb/s，预期录像时间为一个月（按照30天计算），请问客户至少需要多大的硬盘？1643
0243600

2、假定我们采用32k的采样率，对音频进行采样，采样精度为16bit，双声道。请问每秒的数据量是多少字节？如果将上面采样的数据，按照20ms作为一帧，则每帧数据量是多少字节？如果采用I2S总线传输，请问I2S中串行时钟（SCLK）的频率至少应为多少？32K162