笔试题基础(第四篇

1）x是一个行列数均为1000二维数组，下面代码效率执行最高的是（）
A) for(int j=0;j<1000;j++) for(int i=0;i<1000;i++) x[i][j]+=x[j][i];
B) for(int i=0;i<1000;j++) for(int j=0;j<1000;j++) x[i][j]+=x[j][i];
C) for(int i=0;i<1000;j++) for(int j=0;j<1000;j++) x[j][i]+=x[j][i];
D) for(int i=0;i<1000;i++) for(int j=0;j<1000;j++) x[i][j]+=x[i][j];
解答：D

2）不能把字符串”HELLO!”赋给数组b的语句是（）
A) char b[10]={‘H’，’E’，’L’，’L’，’O’，’!’，’\0’};
B) char b[10];b=”HELLO!”;
C) char b[10];strcpy(b，”HELLO!”);
D) char b[10]=”HELLO!”;
解答：B

3) 假设寄存器为8位，用补码形式存储机器数，包括一位符号位，那么十进制数-25在寄存器表示为：
A) 67H
B) 99H
C) E6H
D) E7H
解答：C
　　若a>0，则a的补码为：a;
　　若a=0，则a的补码为：全零，或者全1；
　　若a<0，则a的补码为： a的原码（即|a|）先按位取反，然后加1；
　　令 a = -25，则 a的原码|a| = 25 = (1 1001) = (0001 1001) —>取反—>（1110 0110） —> 加1 —>(1110 0111)—>换成16进制—>(E 7)，即E7H，这里的H代表16进制。选择C)

4）下面程序会输出什么：

static int a=1;
void fun1(void){    a=2;}
void fun2(void){    i
    nt a=3;
}
void fun3(void){ 
    static int a=4;
}
int main(int argc,char**a){ 
     printf(“%d”,a); 
     fun1( ); 
     printf(“%d”,a); 
     fun2( ); 
     printf(“%d”，a);
     fun3( );
    printf(“%d”,a); 
}

A) 1 2 3 4
B) 1 2 2 2
C) 1 2 2 4
D) 1 1 1 4
解答：B
　printf(“%d”,a); //输出全局静态变量，所以输出1
　fun1( ); //a=2所以会修改全局静态变量，输出2
　printf(“%d”,a);
　fun2( ); //int a=3是在func2里的局部变量，所以调用结束就释放了，不影响全局的a值，所以输出2
　printf(“%d”，a);
　fun3( ); //也是局部变量，虽然是静态的但是不会影响全局a的值，仍然输出2
　printf(“%d”,a);
　
5）下面代码不能正确输出hello的选项为

#include<stdio.h>
struct str_t{
   long long len;
   char data[32];
};
struct data1_t{
   long long len;
   int data[2];
};
struct data2_t{
   long long len;
   char *data[1];
};
struct data3_t{
   long long len;
   void *data[];
};
int main(void)
{
   struct str_t str;
   memset((void*)&str,0,sizeof(struct str_t));
   str.len=sizeof(struct str_t)-sizeof(int);
   snprintf(str.data,str.len,"hello");//VS下为_snprintf
   ____________________________________;
   ____________________________________;
   return 0;
}

A) struct data3_t pData=(struct data3_t)&str; printf(“data:%s%s\n”,str.data,(char*)(&(pData->data[0])));
B) struct data2_t pData=(struct data2_t)&str; printf(“data:%s%s\n”,str.data,(char*)(pData->data[0]));
C) struct data1_t pData=(struct data1_t)&str;printf(“data:%s%s\n”,str.data,(char*)(pData->data));
D) struct str_t pData=(struct str_t)&str; printf(“data:%s%s\n”,str.data,(char*)(pData->data));
解答：B

6) 在gcc编译器下，以下说法正确的是

int function(const int src[16]){
    int val1=0;
    int dst[16]={0};
    int val2=0;
    const int *psrc=src;
    //问题1：如下代码行输出什么？
    fprintf(stdout,"size of src=%lu\n",sizeof(src));
    //问题2：如下代码有什么副作用？
    for(int i=0;i<=16;i++){
     dst[i]=*psrc+i;
     psrc++;
    }
    return 0;
}

A) 16,val2会被覆盖
B) 其他三项都不对
C) 8,val2会被覆盖
D) 8,val1会被覆盖
解答：C

7) 在C++语言中，下列说法正确的是：
A) inline函数表示编译器一定会将函数体直接插入到调用此函数的地方，这样可以加快程序的运行速度
B) 局部变量和全局变量不能重名
C) 静态局部变量内存是在运行期分配的，存储在堆栈区
D) C++不是类型安全的语言
解答：A
　　用排除法，可以排除B、C、D。
　　对于B选项，因为局部变量和全局变量是可以重名的，而且一般来说在某个函数体内，局部变量是会覆盖全局变量的。
　　对于C选项，静态局部变量存在静态存储区，而局部变量存储在堆栈区，确切的说是栈区。
　　对于D选项，什么叫类型安全的语言？本人很浅陋的认识是：就C++而言，我们可以把0作为false，非零作为true。一个函数就算是bool类型的，我们还是可以返回int类型，并且自动把0转化成false，非零转化成true。相比之下java不能把int类型转化成bool类型。所以java是一种类型安全的语言，而C++并不是。
　　再看A选项，内联函数与其他普通函数的区别是，内联函数在生成可执行文件时，其代码块是直接嵌入到调用处的，以此减少函数调用的开销提高程序性能，它与宏很类似。但是，C++ primer 上明明白白的写过这么一句话：内联说明（inline specification）对于编译器来说只是一个建议，编译器可以选择忽略这个建议。也就是说，是否以嵌入式方式存在，是由编译器决定的，并不是一定。
　　所以，选A)

8）以下说法正确的是：

void swap_int(int *a,int *b){
  *a=*a+*b;
  *b=*a-*b;
  *a=*a-*b;
}

A) 结果不正确，因为会溢出，用位与的方式就没问题
B) 结果正确，即使会溢出
C) 结果正确，不会溢出
D) 其他选项都不对
解答：B

即 “结果正确，即使会溢出”，选B)

9）在一个64位的操作系统中定义如下结构体：

struct st_task
{
    uint16_t id;
    uint32_t value;
    uint64_t timestamp;
};

同时定义fool函数如下：

void fool()
{
    st_task task = {};
    uint64_t a = 0x00010001;
    memcpy(&task, &a, sizeof(uint64_t));
    printf("%11u,%11u,%11u", task.id, task.value, task.timestamp);
}

上述fool()程序的执行结果为（）
A) 1，0，0
B) 1，1，0
C) 0，1，1
D) 0，0，1
解答：A
　　要考虑内存对齐，uint16_t、unit32_t、unit64_t分别占2个字节、4个字节、8个字节，取中间4个字节为对齐单位，设为m，则对齐后，
　　unit16_t占1个对齐单位m，即4个字节；
　　unit32_t占1个对齐单位m，即4个字节；
　　unit64_t占2个对齐单位2m，即8个字节。
　　也就是：
　　id 占 4个字节，但是高2个字节无效，存储 0x0001 0001，实际为 0x0000 0001；
　　value 占4个字节， 存储 0x0000 0000，实际为 0x0000 0000 ；
　　timestamp 占8个字节， 存储 0x00000000 00000000 ，实际为 0x00000000 00000000。
所以答案是 1 0 0 。

10）定义char dog[]=”wang\0miao”;那么sizeof(dog)与strlen(dog)分别是多少：
A) 10,4
B) 4,4
C) 9,9
D) 9,4
解答：A
　　sizeof返回数组所占的字节数，’wang’ ‘miao’共占8字节，显式’\0’占1字节，字符串末尾隐式’\0’占1字节，共10字节。
　　strlen返回字符串的长度，以遇到’\0’结束符为准，因此为4。

11）Linux下多少个”-“将被打印：

int main(void){
  int i;
  for(i=0;i<4;i++){
  fork();
  printf("-\n");
 }
 return 0;
}

A) 16
B) 30
C) 32
D) 15
解答：B
　　i=0时，主进程和其创建的子进程分别打印’-‘, 打印2个；
　　i=1时，之前两个进程打印’-‘, 每个进程又创建新的子进程， 共打印4个’-‘；
　　i=2时，之前的四个进程分别打印’-‘, 并创建新的子进程, 故共打印8个’-‘；
　　i=3时，之前的8个进程分别打印’-‘, 并创建新的子进程,故共打印16个’-‘；
　　综上所述, 共打印2+4+8+16=30个；

12）以下代码共调用多少次拷贝构造函数：

Widget f(Widget u)
{  
   Widget v(u);
   Widget w=v;
   return w;
}
main(){
    Widget x;
    Widget y=f(f(x));
}

A) 1
B) 3
C) 5
D) 7
解答：D
　　y=f(f(x)) 有两层 f() ，为了说明过程，把里面的一层标明为 f_1 ，外面一层标明为 f_2 。则 7 次调用分别是：
　　　　x -> f_1 的 u
　　　　f_1 的 u -> f_1 的 v
　　　　f_1 的 v -> f_1 的 w
　　　　f_1 的 w -> f_2 的 u
　　　　f_2 的 u -> f_2 的 v
　　　　f_2 的 v -> f_2 的 w
　　　　f_2 的 w -> y