C语言面试题之华为篇(答案全)

一、数组和指针

1、 
数组a[N],存放了1至N-1个数,其中某个数重复一次。写一个函数,找出被重复的数字时间复杂度必须为o(N)函数原型:

(1)什么是预编译,何时需要预编译:
答案:
1、总是使用不经常改动的大型代码体。
2、程序由多个模块组成,所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下,可以将所有包含文件预编译为一个预编译头。
(2)char * const p char const * p const char *p
上述三个有什么区别?
答案:
char * const p; //常量指针,p的值不可以修改
char const * p;//指向常量的指针,指向的常量值不可以改 const char *p;
//和char const *p
(3)char str1[] = “abc”; char str2[] = “abc”; const char str3[] =
“abc”; const char str4[] = “abc”; const char *str5 = “abc”; const
char *str6 = “abc”; char *str7 = “abc”; char *str8 = “abc”; cout <
< ( str1 == str2 ) < < endl; cout < < ( str3 == str4 )
< < endl; cout < < ( str5 == str6 ) < < endl; cout
< < ( str7 == str8 ) < < endl;
结果是:0 0 1 1
str1,str2,str3,str4是数组变量,它们有各自的内存空间;而str5,str6,str7,str8是指针,它们指向相同的常量区域。
(4)以下代码中的两个sizeof用法有问题吗?
[C易] void UpperCase( char str[] ) // 将 str
中的小写字母转换成大写字母 { for( size_t i=0; i
<sizeof(str)/sizeof(str[0]); ++i ) if( a <=str[i] && str[i]
<=z ) str[i] -= (a-A ); } char str[] = “aBcDe”; cout < <
“str字符长度为: ” < < sizeof(str)/sizeof(str[0]) < < endl;
UpperCase( str ); cout < < str < < endl;
答案:函数内的sizeof有问题。根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组,因此其大小为6,因为还有,函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此sizeof作用于上只将其当指针看,一个指针为4个字节,因此返回4。
(5)一个32位的机器,该机器的指针是多少位答案:
指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。
6。main() { int a[5]={1,2,3,4,5}; int *ptr=(int *)(&a+1);
printf(“%d,%d”,*(a+1),*(ptr-1)); } 答案:2。5
*(a+1)就是a[1],*(ptr-1)就是a[4],执行结果是2,5
&a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小(本例是5个int)
int *ptr=(int *)(&a+1); 则ptr实际是&(a[5]),也就是a+5 原因如下:
&a是数组指针,其类型为 int (*)[5];
而指针加1要根据指针类型加上一定的值,不同类型的指针+1之后增加的大小不同
a是长度为5的int数组指针,所以要加 5*sizeof(int) 所以ptr实际是a[5]
但是prt与(&a+1)类型是不一样的(这点很重要) 所以prt-1只会减去sizeof(int*)
a,&a的地址是一样的,但意思不一样,a是数组首地址,也就是a[0]的地址,&a是对象(数组)首地址,a+1是数组下一元素的地址,即a[1],&a+1是下一个对象的地址,即a[5].
7。请问以下代码有什么问题: int main() { char a; char *str=&a;
strcpy(str,”hello”); printf(str); return 0; }
答案:没有为str分配内存空间,将会发生异常问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果,但因为越界进行内在读写而导致程序崩溃。
8。char* s=”AAA”; printf(“%s”,s); s[0]=B; printf(“%s”,s);
有什么错?答案:”AAA”是字符串常量。s是指针,指向这个字符串常量,所以声明s的时候就有问题。
cosnt char* s=”AAA”;
然后又因为是常量,所以对是s[0]的赋值操作是不合法的。
9。写一个“标准”宏,这个宏输入两个参数并返回较小的一个。答案:.#define
Min(X, Y) ((X)>(Y)?(Y):(X)) //结尾没有‘;’
10。嵌入式系统中经常要用到无限循环,你怎么用C编写死循环。答案:while(1){}或者for(;;)
11。关键字static的作用是什么?答案:定义静态变量
12。关键字const有什么含意?答案:表示常量不可以修改的变量。
13。关键字volatile有什么含意?并举出三个不同的例子?答案:提示编译器对象的值可能在编译器未监测到的情况下改变。
14。int (*s[10])(int) 表示的是什么啊?答案:int (*s[10])(int)
函数指针数组,每个指针指向一个int func(int param)的函数。
15。有以下表达式: int a=248; b=4;int const c=21;const int *d=&a; int
*const e=&b;int const *f const =&a;
请问下列表达式哪些会被编译器禁止?为什么?答案:*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
*c 这是个什么东东,禁止 *d 说了是const, 禁止 e = &a 说了是const 禁止
const *f const =&a; 禁止
16交换两个变量的值,不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;
答案:有两种解法, 一种用算术算法, 一种用^(异或) a = a + b; b = a – b; a
= a – b; or a = a^b;// 只能对int,char.. b = a^b; a = a^b; or a ^= b ^=
a;
17.c和c++中的struct有什么不同?答案:c和c++中struct的主要区别是c中的struct不可以含有成员函数,而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同,struct默认为public,而class默认为private
18.#include <stdio.h> #include <stdlib.h> void
getmemory(char *p) { p=(char *) malloc(100); strcpy(p,”hello world”);
} int main( ) { char *str=NULL; getmemory(str); printf(“%s/n”,str);
free(str); return 0; } 答案:程序崩溃,getmemory中的malloc
不能返回动态内存, free()对str操作很危险
19.char szstr[10]; strcpy(szstr,”0123456789″);
产生什么结果?为什么?答案: 长度不一样,会造成非法的OS
20.列举几种进程的同步机制,并比较其优缺点。答案: 原子操作 信号量机制
自旋锁 管程,会合,分布式系统
21.进程之间通信的途径答案:共享存储系统消息传递系统管道:以文件系统为基础
22.进程死锁的原因答案:资源竞争及进程推进顺序非法
23.死锁的4个必要条件答案:互斥、请求保持、不可剥夺、环路
24.死锁的处理答案:鸵鸟策略、预防策略、避免策略、检测与解除死锁
25.
操作系统中进程调度策略有哪几种?答案:FCFS(先来先服务),优先级,时间片轮转,多级反馈
26.类的静态成员和非静态成员有何区别?答案:类的静态成员每个类只有一个,非静态成员每个对象一个
27.纯虚函数如何定义?使用时应注意什么?答案:virtual void f()=0;
是接口,子类必须要实现
28.数组和链表的区别答案:数组:数据顺序存储,固定大小连表:数据可以随机存储,大小可动态改变
29.ISO的七层模型是什么?tcp/udp是属于哪一层?tcp/udp有何优缺点?答案:应用层表示层会话层运输层网络层物理链路层物理层
tcp /udp属于运输层 TCP
服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。与
TCP 不同, UDP 并不提供对 IP
协议的可靠机制、流控制以及错误恢复功能等。由于 UDP 比较简单, UDP
头包含很少的字节,比 TCP 负载消耗少。 tcp:
提供稳定的传输服务,有流量控制,缺点是包头大,冗余性不好 udp:
不提供稳定的服务,包头小,开销小
30:(void *)ptr 和
(*(void**))ptr的结果是否相同?其中ptr为同一个指针答案:.(void *)ptr
和 (*(void**))ptr值是相同的
31:int main() { int x=3; printf(“%d”,x); return 1; }
问函数既然不会被其它函数调用,为什么要返回1?答案:mian中,c标准认为0表示成功,非0表示错误。具体的值是某中具体出错信息
32,要对绝对地址0x100000赋值,我们可以用 (unsigned int*)0x100000 =
1234;
那么要是想让程序跳转到绝对地址是0x100000去执行,应该怎么做?答案:*((void
(*)( ))0x100000 ) ( ); 首先要将0x100000强制转换成函数指针,即: (void
(*)())0x100000 然后再调用它: *((void (*)())0x100000)();
用typedef可以看得更直观些: typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
33,已知一个数组table,用一个宏定义,求出数据的元素个数答案:#define
NTBL #define NTBL (sizeof(table)/sizeof(table[0]))
34。线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?
答案:进程是死的,只是一些资源的集合,真正的程序执行都是线程来完成的,程序启动的时候操作系统就帮你创建了一个主线程。每个线程有自己的堆栈。
DLL中有没有独立的堆栈,这个问题不好回答,或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行,只有线程拥有堆栈,如果DLL中的代码是EXE中的线程所调用,那么这个时候是不是说这个DLL没有自己独立的堆栈?如果DLL中的代码是由DLL自己创建的线程所执行,那么是不是说DLL有独立的堆栈?以上讲的是堆栈,如果对于堆来说,每个DLL有自己的堆,所以如果是从DLL中动态分配的内存,最好是从DLL中删除,如果你从DLL中分配内存,然后在EXE中,或者另外一个DLL中删除,很有可能导致程序崩溃
35。unsigned short A = 10; printf(“~A = %un”, ~A); char c=128;
printf(“c=%dn”,c); 输出多少?并分析过程答案:第一题,~A
=0xfffffff5,int值 为-11,但输出的是uint。所以输出4294967285
第二题,c=0x10,输出的是int,最高位为1,是负数,所以它的值就是0x00的补码就是128,所以输出-128。这两道题都是在考察二进制向int或uint转换时的最高位处理。

1、数组和指针的存储

写出下面的输出结果:

char str1[] = “abc”;

char str2[] = “abc”;

const char str3[] = “abc”;

const char str4[] = “abc”;

const char *str5 = “abc”;

const char *str6 = “abc”;

char *str7 = “abc”;

char *str8 = “abc”;

cout << ( str1 == str2 ) << endl;

cout << ( str3 == str4 ) << endl;

cout << ( str5 == str6 ) << endl;

cout << ( str7 == str8 ) << endl;

结果是:0 0 1 1

解答:str1,str2,str3,str4是数组变量,它们有各自的内存空间;

而str5,str6,str7,str8是指针,它们指向相同的常量区域。

 


2、数组和指针的取值

写出输出结果

void main()

{

int a[5]={1,2,3,4,5};

int *ptr=;

printf(“%d,%d”,*,*;

}

输出:2,5

*就是a[1],*就是a[4],执行结果是2,5

注意:&a+1不是首地址+1,系统会认为加一个a数组的偏移,是偏移了一个数组的大小,int
*ptr=;则ptr实际是&,也就是a+5。原因如下:

&a是数组指针,其类型为 int [5];而指针加1要根据指针类型加上一定的值,

不同类型的指针+1之后增加的大小不同,a是长度为5的int数组指针,所以要加
5*sizeof,所以ptr实际是a[5];但是prt与类型是不一样的,所以prt-1只会减去sizeof;a,
&a的地址是一样的,但意思不一样,a是数组首地址,也就是a[0]的地址,&a是对象首地址,a+1是数组下一元素的地址,即a[1],&a+1是下一个对象的地址,即a[5]。

 

3、数组越界

下面这个程序执行后会有什么错误?

#define MAX 255

int main()

{

unsigned char A[MAX],i;//i被定义为unsigned char

for (i=0;i<=MAX;i++)

A[i]=i;

}

答:死循环加数组越界访问(C/C++不进行数组越界检查)。

其一,MAX=255,数组A的下标范围为:0…MAX-1。

其二,当i循环到255时,循环内执行:A[255]=255;这句本身没有问题,但是返回for
(i=0;i<=MAX;i++)语句时,由于unsigned
char的取值范围在,i++以后i又为0了,会无限循环下去。

int find(int a[],int n){ 

4、指针变量存储

请问以下代码有什么问题:

int main()

{

char a;

char *str=&a;

strcpy(str,”hello”);

printf;

return 0;

}

没有为str分配内存空间,将会发生异常

问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果,但因为越界进行内在读写而导致程序崩溃。

    int temp[n]={0}; 

5、指针变量的赋值

以下程序有什么错?

char* s=”AAA”;

printf;

s[0]=’B’;

printf;

“AAA”是字符串常量。s是指针,指向这个字符串常量,所以声明s的时候就有问题。应写成const
char* s=”AAA”;

然后又因为是常量,所以对是s[0]的赋值操作是不合法的。

    int i; 

6、指针计算

分析以下代码的输出:

int arr[] = {6,7,8,9,10};

int *ptr = arr;

*+=123;

printf(“ %d %d ”, *ptr, *;

答:输出:8,8

对于*+=123;先做加法6+123,然后++,指针指向7;对于printf(“ %d %d ”,
*ptr, *;从后往前执行,指针先++,指向8,然后输出8,紧接着再输出8。

    for(i=0;i<n;i++){ 

7、指针存储

分析下面的代码:

char *a = “hello”;

char *b = “hello”;

if

printf;

else

printf;

答:在VC是YES 在C是NO。

hello是一个常量字符串,位于静态存储区,它在程序生命期内恒定不变。如果编译器优化的话,会有可能a和b同时指向同一个hello的,则地址相同。如果编译器没有优化,那么就是两个不同的地址,则不同。

        if(temp[a[i]] != 0){ 

8、空指针

ptr 和 )ptr的结果是否相同?

答:其中ptr为同一个指针,ptr 和 )ptr值是相同的

            return a[i]; 

二、关键字

        }else{ 

1、sizeof求字节

某32位系统下,计算sizeof 的值:

char str[] = “abcde”;

char *p = str ;

int n = 10;

sizeof = ?

sizeof = ?

sizeof = ?

void Foo ( char str[100]){

sizeof = ?

}

void *p = malloc;

sizeof = ?

答:4 4 4

            temp[a[i]]=1; 

2、sizeof求字节

给出下面程序的答案

typedef struct AA

{

int b1:5;

int b2:2;

}AA;

void main()

{

AA aa;

char cc[100];

strcpy(cc,”0123456789abcdefghijklmnopqrstuvwxyz”);

memcpy(&aa,cc,sizeof;

cout << aa.b1 <<endl;

cout << aa.b2 <<endl;

}

答:是 -16和1。

首先sizeof的大小为4,b1和b2分别占5bit和2bit,经过strcpy和memcpy后,aa的4个字节所存放的值是:0,1,2,3的ASC码,即00110000,00110001,00110010,00110011;所以,最后一步:显示的是这4个字节的前5位,和之后的2位,分别为:10000和01;因为int是有正负之分,所以:答案是-16和1。

        } 

3、sizeof用于数组作为函数参数

以下代码中的两个sizeof用法有问题吗?

void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母

{

for( size_t i=0; i<sizeof/sizeof; ++i )

if( ‘a'<=str[i] && str[i]<=’z’ )

str[i] -= ;

}

char str[] = “aBcDe”;

cout << “str字符长度为: ” << sizeof/sizeof << endl;

UpperCase;

cout << str << endl;

答:函数内的sizeof有问题。根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组,因此其大小为6,函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此只将其当指针看,一个指针为4个字节,因此返回4。

    } 

4、const的使用

有以下表达式:

int a=248; b=4;

int const c=21;

const int *d=&a;

int *const e=&b;

int const *f const =&a;

请问下列表达式哪些会被编译器禁止?为什么?

*c=32; d=&b; *d=43; e=34; e=&a; f=0x321f;

*c 这是个什么东东,禁止;

*d 说了是const,禁止;

e = &a 说了是const 禁止;

const *f const =&a; 禁止。

5、static的使用

下面的函数实现在一个数上加一个数,有什么错误?

int add_n

{

static int i = 100;

i += n;

return i;

}

答:不应该用static,因为static只保留第一次初始化的值,第二次调用时得不到正确的结果。

 

6、static的应用

写出程序运行结果:

int sum

{

auto int c=0;

static int b=3;

c+=1;

b+=2;

return;

}

void main()

{

int i;

int a=2;

for(i=0;i<5;i++)

{

printf(“%d,”, sum;

}

}

答:输出:8,10,12,14,16,

static会保存上次结果,记住这一点

 

三、函数

2、一语句实现x是否为2的若干次幂的判断

1、主函数的返回值

主函数既然不会被其它函数调用,为什么要返回1?

int main()

{

int x=3;

printf;

return 1;

}

答:main函数的返回值,用于说明程序的退出状态。如果返回0,则代表程序正常退出;返回其它数字的含义则由系统决定。通常,返回非零代表程序异常退出。

 

2、指针用于函数参数

void GetMemory(char **p, int num){

*p = malloc;

}

void Test{

char *str = NULL;

GetMemory(&str, 100);

strcpy(str, “hello”);

printf;

}

请问运行Test 函数会有什么样的结果?

答:输出“hello”

void Test{

char *str = malloc;

strcpy(str, “hello”);

free;

if(str != NULL){

strcpy(str, “world”);

printf;

}

}

请问运行Test 函数会有什么样的结果?

答:输出“world”

char *GetMemory{

char p[] = “hello world”;

return p;

}

void Test{

char *str = NULL;

str = GetMemory();

printf;

}

请问运行Test 函数会有什么样的结果?

答:无效的指针,输出不确定

int i = 512; 

3、函数调用先后关系

写出输出结果:

#include <stdio.h>

void foo(int m, int n)

{

printf(“m=%d, n=%dn”, m, n);

}

int main()

{

int b = 3;

foo(b+=3, ++b);

printf(“b=%dn”, b);

return 0;

}

答:输出:m=7,n=4,b=7

这种方式和编译器中得函数调用关系相关即先后入栈顺序。不过不同编译器得处理不同。也是因为C标准中对这种方式说明为未定义,所以各个编译器厂商都有自己得理解,所以最后产生得结果完全不同。

cout << ((i & (i – 1)) ? false : true) << endl; 

4、函数地址

请问一下程序将输出什么结果?

char *RetMemoy

{

char p[] = “hello world”;

return p;

}

void Test

{

char *str = NULL;

str = RetMemory();

printf;

}

RetMemoy执行完毕,p资源被回收,指向未知地址。返回地址,str的内容应是不可预测的,
打印的应该是str的地址。

 

5、字符串赋值函数strcpy

下面的语句会出现什么结果?

char szstr[10];

strcpy (szstr,”0123456789″);

答:长度不一样,会造成非法的OS,应该改为char szstr[11]
,注意strcpy会拷贝””。

   
按位与运算符a&b,对b中为1的位如果a中也为1则保留,a中其余位全部置0,剩下的a即为结果也可以理解为保留a中与b中位1对应的位,其余置0。其余按位运算符类似,将a与b按位做相应运算,所得值即结果。

6、用strcpy赋值字符串

对下面程序进行分析:

void test2()

{

char string[10], str1[10];

int i;

for(i=0; i<10; i++)

{

str1[i] = ‘a’;

}

strcpy( string, str1 );

}

答:
str1不能在数组内结束:因为str1的存储为:{a,a,a,a,a,a,a,a,a,a},没有’’,所以不能结束;strcpy(
char *s1,char
*s2)他的工作原理是,扫描s2指向的内存,逐个字符付到s1所指向的内存,直到碰到’’,因为str1结尾没有’’,所以具有不确定性。

正确应如下:

void test2()

{

char string[10], str1[10];

int i;

for(i=0; i<9; i++)

{

str1[i] = ‘a’+i; //把abcdefghi赋值给字符数组

}

str[i]=’’;//加上结束符

strcpy( string, str1 );

}

 

四、结构体

3、

1、结构体和联合体字节计算

设有以下说明和定义:

typedef union {long i; int k[5]; char c;} DATE;

struct data { int cat; DATE cow; double dog;} too;

DATE max;

则语句 printf(“%d”,sizeof(struct data)+sizeof);的执行结果是?

结果是:52。

DATE是一个union, 变量公用空间,里面最大的变量类型是int[5],
占用20个字节,所以它的大小是20;data是一个struct,
每个变量分开占用空间,依次为int4 + DATE20 + double8 = 32,所以结果是 20

  • 32 = 52。

当然…在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 +
double8 = 20。

 

2、结构体字节计算

struct name1{

char str;

short x;

int num;

}

struct name2{

char str;

int num;

short x;

}

sizeof(struct name1),sizeof(struct name2)的结果是多少?

答:sizeof(struct name1)=8,sizeof(struct name2)=12

在第二个结构中,为保证num按四个字节对齐,char后必须留出3字节的空间;同时为保证整个结构的自然对齐,在x后还要补齐2个字节,这样就是12字节。

 

3、结构体位域字节计算

struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

struct s2

{

int i: 8;

int j: 4;

double b;

int a:3;

};

printf(“sizeof= %dn”, sizeof;

printf(“sizeof= %dn”, sizeof;

答:输出是: 16, 24

对于struct
s1,理论上是这样的,首先是i在相对0的位置,占8位一个字节,然后,j就在相对一个字节的位置,由于一个位置的字节数是4位的倍数,因此不用对齐,就放在那里了,然后是a,要在3位的倍数关系的位置上,因此要移一位,在15位的位置上放下,目前总共是18位,折算过来是2字节2位的样子,由于double是8字节的,因此要在相对0要是8个字节的位置上放下,因此从18位开始到8个字节之间的位置被忽略,直接放在8字节的位置了,因此,总共是16字节。

对于struct
s2,最后会对照是不是结构体内最大数据的倍数,不是的话,会补成是最大数据的倍数。

char str1[] = “abc”; 

五、动态内存分配

char str2[] = “abc”; 

1、动态内存分配

下面的程序会出现什么结果?

#include <stdio.h>

#include <stdlib.h>

void getmemory

{

p= malloc;

strcpy(p,”hello world”);

}

int main

{

char *str=NULL;

getmemory;

printf(“%s/n”,str);

free;

return 0;

}

答:程序崩溃,getmemory中的malloc 不能返回动态内存,
free()对str操作很危险。

const char str3[] = “abc”; 

2、动态内存分配

下面程序的输出结果是什么?

void GetMemory(char **p,int num)

{

*p=malloc;

}

int main()

{

char *str=NULL;

GetMemory(&str,100);

strcpy(str,”hello”);

free;

if(str!=NULL)

{

strcpy(str,”world”);

}

printf(“n str is %s”,str);

getchar();

}

答:输出str is world。

free 只是释放的str指向的内存空间,它本身的值还是存在的。

const char str4[] = “abc”; 

六、其他

const char *str5 = “abc”; 

1、无符号类型整数自动转换

下面的代码输出是什么,为什么?

void foo

{

unsigned int a = 6;

int b = -20;

(a+b > 6) ? puts : puts(“<= 6”);

}

这个问题测试你是否懂得C语言中的整数自动转换原则,我发现有些开发者懂得极少这些东西。不管如何,这无符号整型问题的答案是输出是
“>6″。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数,所以该表达式计算出的结果大于6。

const char *str6 = “abc”; 

2、表达式是否合理

下面的结构是合法的吗?

int a = 5, b = 7, c;

c = a+++b;

上面的例子是完全合乎语法的。根据最处理原则,编译器应当能处理尽可能所有合法的用法。因此,上面的代码被处理成:c
= a++ + b;

因此, 这段代码持行后a = 6, b = 7, c = 12。

char *str7 = “abc”; 

3、自增运算

请写出下列代码的输出内容

#include<stdio.h>

main()

{

int a,b,c,d;

a=10;

b=a++;

c=++a;

d=10*a++;

printf(“b,c,d:%d,%d,%d”,b,c,d);

return 0;

}

答:10,12,120

char *str8 = “abc”; 

4、自增运算

写出表达式计算 a的值:

int a = 4;

a += ;

a += ;

+= a;

+= ;

答:依次为9,10,10,11

cout << ( str1 == str2 ) << endl; 

5、循环嵌套

请问下面程序有什么错误?

int a[60][250][1000],i,j,k;

for(k=0;k<=1000;k++)

for(j=0;j<250;j++)

for(i=0;i<60;i++)

a[i][j][k]=0;

答案:把循环语句内外换一下

cout << ( str3 == str4 ) << endl; 

6、死循环

请问下面程序会出现什么情况?

. #define Max_CB 500

void LmiQueryCSmd(Struct MSgCB * pmsg)

{

unsigned char ucCmdNum;

……

for(ucCmdNum=0;ucCmdNum<Max_CB;ucCmdNum++)

{

……;

}

}

答案:死循环

cout << ( str5 == str6 ) << endl; 

7、绝对地址赋值

对绝对地址0x100000赋值且想让程序跳转到绝对地址是0x100000去执行:

(unsigned int*)0x100000 = 1234;

首先要将0x100000强制转换成函数指针,即:

0x100000

然后再调用它:

*0x100000)();

用typedef可以看得更直观些:

typedef void voidFuncPtr;

*((voidFuncPtr)0x100000)();

cout << ( str7 == str8 ) << endl; 

8、二进制转换

下列代码的输出值为多少?

unsigned short A = 10;

printf(“~A = %un”, ~A);

char c=128;

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

答:~A =0xfffffff5,int值 为-11,但输出的是uint。所以输出4294967285;

c=0x10,输出的是int,最高位为1,是负数,所以它的值就是0x00的补码就是128,所以输出-128。

这两道题都是在考察二进制向int或uint转换时的最高位处理。

 

9、交换两个变量的值,不使用第三个变量。

即a=3,b=5,交换之后a=5,b=3;

有两种解法, 一种用算术算法, 一种用^(异或)

a = a + b;

b = a – b;

a = a – b;

or

a = a^b;// 只能对int,char..

b = a^b;

a = a^b;

or

a ^= b ^= a;

   结果是:0 0 1 1

10、用宏定义写出swap

#define swap/

x = x + y;/

y = x – y;/

x = x – y;

   
解答:str1,str2,str3,str4是数组变量,它们有各自的内存空间;而str5,str6,str7,str8是指针,它们指向相同的常量区域。注意C语言不是这样的。常量的地址也不一样。

11、一句代码实现x是否为2的若干次幂的判断

int i = 512;

cout << boolalpha << ((i & ? false : true) << endl;

—————END——————-

威尼斯人平台 1

(人言落日是天涯,望极天涯不见家)

 

4、指针的引用……

 

 

main() 

int a[5]={1,2,3,4,5}; 

int *ptr=(int *)(&a+1); 

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

      输出:2,5 

      &a是数组指针,其类型为int
(*)[5];而指针加1要根据指针类型加上一定的值,不同类型的指针+1之后增加的大小不同。a是长度为5的int数组指针,所以要加5*sizeof(int)
。所以ptr实际是a[5]。但是prt与(&a+1)类型是不一样的(这点很重要),所以prt-1只会减去sizeof(int*)。a,&a的地址是一样的,但意思不一样,a是数组首地址,也就是a[0]的地址,&a是对象(数组)首地址,a+1是数组下一元素的地址,即a[1],&a+1是下一个对象的地址,即a[5].

 

   5、死锁的4个必要条件

         互斥、请求保持、不可剥夺、环路

 

   6、死锁的处理

        鸵鸟策略、预防策略、避免策略、检测与解除死锁

 

   7、操作系统中进程调度策略有哪几种?

        FCFS(先来先服务),优先级,时间片轮转,多级反馈

 

   8、tcp/udp是属于哪一层?tcp/udp有何优缺点?

 

威尼斯人平台 2

 

tcp /udp属于运输层

TCP
服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。与TCP
不同,UDP 并不提供对IP 协议的可靠机制、流控制以及错误恢复功能等。由于UDP
比较简单,UDP 头包含很少的字节,比TCP 负载消耗少。

tcp: 提供稳定的传输服务,有流量控制,缺点是包头大,冗余性不好

udp: 不提供稳定的服务,包头小,开销小

 

     9、(void *)ptr
和(*(void**))ptr的结果是否相同?其中ptr为同一个指针。

 

      是一样的。

     第一个没问题 
就是把ptr强制转化为指向空类型的指针。第二个(*(void**))ptr 
先看里面的  这是转化成指向void指针的指针 
也就是二级指针。再在前面加上*就是取内容 
那么内容也是个指针。这个指针是指向空类型的 
所以强制转化后和第一个是一样的。

 

   
10、要对绝对地址0x100000赋值怎么做?要是想让程序跳转到绝对地址是0x100000去执行,应该怎么做?

 

         (unsigned int*)0x100000 = 1234

 

          首先要将0x100000强制转换成函数指针,即: (void
(*)())0x100000。然后再调用它:

               *((void (*)())0x100000)();

       用typedef可以看得更直观些: typedef void(*)() voidFuncPtr; 
*((voidFuncPtr)0x100000)();    

 

 

 

 

    

 本篇博客出自  阿修罗道

数组a[N],存放了1至N-1个数,其中某个数重复一次。写一个函数,找出被重复的数字时间复杂度必须为o(N)函数原型:
int find(int a[],…

相关文章