简单C++ 自测/2016奇虎360 C++研发工程师内推笔试题

• 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为__________________________
• A、int AA::a( )
• B、int AA:a()
• C、AA::a()
• D、AA::int a()
• 在下列关于C++函数的叙述中，正确的是__________________
• A、每个函数至少要有一个参数
• B、每个函数都必须返回一个值
• C、函数在被调用之前必须先声明
• D、函数不能自己调用自己
• 下列关于this指针的说法正确的是_______________
• A、this指针存在于每个函数之中
• B、在类的非静态函数中this指针指向调用该函数的对象
• C、this指针是指向虚函数表的指针
• D、this指针是指向类的函数成员的指针
• 有如下程序：  

#include <iostream>
using namespace std;
class point
{
 public:
 static int number;
 public:
point() { number++;}
~point() {number--;}
};
 int point::number=0;
 void main()
 { point *ptr;
   point A,B;
{
point *ptr_point=new point[3];
     ptr=ptr_point;
}
 point C;
 delete[] ptr;
cout<<point::number;
 }

• 
  程序结果为________________
   
• A、3
• B、4
• C、6
• D、7
• 有如下程序：  

• #include<iostream>
using namespace std;
class MyClass{
public:
MyClass(int i=0){cout<<1;}
MyClass(const MyClass&x){cout<<2;}
MyClass& operator=(const MyClass&x){cout<<3; return *this;}
~MyClass(){cout<<4;}
};
 
int main(){
　　MyClassobj1(1),obj2(2),obj3(obj1);
　　obj1=obj2;
　　return0;

•  
• A、1123444
• B、11114444
• C、121444
• D、11314444
• 有如下程序：  

#include<iostream>
using namespace std;
class Test{
public:
Test(){}
~Test(){cout<<'#';}
};
int main(){
Test  temp[2], *pTemp[2];
return 0;
}

• 
  执行这个程序输出星号（#）的个数为__________
   
• A、1
• B、2
• C、3
• D、4
• 有下类定义  
  Class A {
  Char *a;
  Public:
  A():a(0){}
  A(char *aa) {//把aa所指字符串拷贝到a所指向的存储空间
  A=___________________;
  Strcpy(a,aa);
  ~A() {delete [] a;}
  };
  正确的选择是__________________
   
• A、new char[strlen(aa)+1]
• B、char[strlen(aa)+1]
• C、char[strlen(aa)]
• D、new char[sizeof(aa)-1]
• 下列关于虚基类的描述中，错误的是________________
• A、使用虚基类可以消除由多继承产生的二义性
• B、构造派生类对象时，虚基类的构造函数只被调用一次
• C、声明 class B:virtual public A 说明类B为虚基类
• D、建立派生类对象时，首先调用虚基类的构造函数
• 下面程序的输出结果是_______________  

#include <iostream>
using namespace std;
class Sample
{
friend long fun (Sample s)
 {
   if (s.x < 2) return 1;
   return s.x * fun(Sample(s.x-1));
 }
 public:
 Sample (long a) { x = a; }
 private:
 long x;
};
void main()
{
 int sum = 0;
 for (int i=0; i<4; i++)
 {
   sum += fun(Sample(i));
 }
 cout << sum;

• 
   
• A、12
• B、16
• C、10
• D、34
• 下面的程序段的运行结果为___________________  
  char str[] = "job", *p = str;
  cout << *(p+2) << endl;
   
• A、98
• B、无输出结果
• C、字符’b’的地址
• D、字符’b’
• 下面程序的输出结果是________________

•  #include <iostream>
 using namespace std;
 class Base
 {
   public:
    virtual void f() { cout << “f0+”; }
    void g() { cout << “g0+”; }
 };
 class Derived : public Base
 {
   public:
    void f() { cout << “f+”; }
    void g() { cout << “g+”; }
 };
 void main() 
 { 
 Derived d; 
 Base *p = &d; 
 p->f(); 
 p->g();
 }

• A、f+g+
• B、f0+g+
• C、f+g0+
• D、f0+g0+
• 下列情况中，哪一种情况不会调用拷贝构造函数________________
• A、用派生类的对象去初始化基类对象时
• B、将类的一个对象赋值给该类的另一个对象时
• C、函数的形参是类的对象，调用函数进行形参和实参结合时
• D、函数的返回值是类的对象，函数执行返回调用者时

• 
  

• 下面程序的输出结果是________________

• #include <iostream>
using namespace std;
class Base
{
 public:
  Base(int i) { cout << i; }
  ~Base () { }
};
class Base1: virtual public Base
{
 public:
  Base1(int i, int j=0) : Base(j) { cout << i; }
  ~Base1() {}
};
class Base2: virtual public Base
{
 public:
  Base2(int i, int j=0) : Base(j) { cout << i; }
  ~Base2() {}
};
class Derived : public Base2, public Base1
{
 public:
  Derived(int a, int b, int c, int d) : mem1(a), mem2(b), Base1(c),
                                        Base2(d), Base(a)
   { cout << b; }
 private:
  Base2 mem2;
  Base1 mem1;
};
void main() { Derived objD (1, 2, 3, 4); }

• A、134122
• B、123412
• C、14302012
• D、143212

•  
•  
• 2016奇虎360 C++研发工程师内推笔试题
•  
• 1 x是一个行列数均为1000二维数组，下面代码效率执行最高的是（）
  for(int j=0;j<1000;j++) for(int i=0;i<1000;i++) x[i][j]+=x[j][i];
  for(int i=0;i<1000;j++) for(int j=0;j<1000;j++) x[i][j]+=x[j][i];
  for(int i=0;i<1000;j++) for(int j=0;j<1000;j++) x[j][i]+=x[j][i];
  for(int i=0;i<1000;i++) for(int j=0;j<1000;j++) x[i][j]+=x[i][j];
  
  
  2 不能把字符串"HELLO!"赋给数组b的语句是（）
  char b[10]={'H'，'E'，'L'，'L'，'O'，'!'，'\0'};
  char b[10];b="HELLO!";
  char b[10];strcpy(b，"HELLO!");
  char b[10]="HELLO!";
  b是表示数组的首地址，不能赋值
  
  3 假设寄存器为8位，用补码形式存储机器数，包括一位符号位，那么十进制数-25在寄存器表示为：
  67H
  99H
  E6H
  E7H
  十进制数-25的原码为10011001，反码为11100110，补码是反码加1，即为11100111，转化为十六进制即为E7
  
  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); 
}

• 1 2 3 4
  1 2 2 2
  1 2 2 4
  1 1 1 4
  静态局部变量只对定义它的函数体始终可见，函数体执行完过后虽然还存在，但是无法被其他的使用了
  
  5下面这段代码的输出结果为：

void change(int*a, int&b, int c){ 
    c=*a; 
    b=30; 
    *a=20;
}
int main ( ){ 
     int a=10, b=20, c=30; 
     change(&a,b,c); 
     printf(“%d,%d,%d,”,a,b,c)； 
     return 0；
}

• 20，30，30
  10，20，30
  20,30，10
  10,30，30
  传值不会改变变量的值，但是传引用和传指针都会改变。
  
  6在c++中，

const int i = 0; 
int *j = (int *) &i; 
*j = 1; 
printf("%d,%d", i, *j)

• 输出是多少?
  0，1
  1，1
  1，0
  0，0
  C++中的常量折叠：指const变量（即常量）值 放在编译器的符号表中 ，计算时编译器直接从表中取值，省去了访问内存的时间，从而达到了优化。
  
  7请问下面的程序最后会产生多少个进程：

int main(　）{ 
     int i; 
     for(i = 0; i<5;i++){ 
        int pid = fork(); 
        if(pid == 0){ 
            //do something 
        } else { 
        //do something 
        } 
        }
    // do somthing,sleep
    return 0;
}

• 5
  10
  15
  32
  
  
  8下面代码不能正确输出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;
}

• struct data3_t *pData=(struct data3_t*)&str; printf("data:%s%s\n",str.data,(char*)(&(pData->data[0])));
  struct data2_t *pData=(struct data2_t*)&str; printf("data:%s%s\n",str.data,(char*)(pData->data[0]));
  struct data1_t *pData=(struct data1_t*)&str;printf("data:%s%s\n",str.data,(char*)(pData->data));
  struct str_t *pData=(struct str_t*)&str; printf("data:%s%s\n",str.data,(char*)(pData->data));
  
  http://www.nowcoder.com/test/question/done?tid=1103973&qid=25235#summary
  
  9下面代码段输出为：

int i;
  for(i=0;i<3;i++){
    switch(i){
    case 0:printf("%d",i);
    case 2:printf("%d",i);
    default:printf("%d",i);
    }
  }

• 000111
  000020
  000102
  000122
  
  
  10

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;
}

• 在gcc编译器下，以下说法正确的是
  16,val2会被覆盖
  其他三项都不对
  8,val2会被覆盖
  8,val1会被覆盖

函数调用时，局部变量按照申明顺序入栈，而栈又是从高地址往低地址生长的

所以，val1的地址在dst的地址后面，当访问dst越界时，会覆盖掉val1的地址 

• 
  11下面程序的输出是：

#define f(x) x*x
main (){
  int a=6,b=2,c;
  c=f(a)/f(b);
  printf("%d",c);
}

• 3
  18
  36
  9
  
  
  12在64位操作系统上，如下数据结构占用的存储空间大小为多少字节

struct A{
   unsigned int a;
   char b[2];
   double c;
   short d;
}

• 12
  24
  20
  16
  
  
  13 在C++语言中，下列说法正确的是：
  inline函数表示编译器一定会将函数体直接插入到调用此函数的地方，这样可以加快程序的运行速度
  局部变量和全局变量不能重名
  静态局部变量内存是在运行期分配的，存储在堆栈区
  C++不是类型安全的语言
  
  
  14
  void swap_int(int *a,int *b){
    *a=*a+*b;
    *b=*a-*b;
    *a=*a-*b;
  }
  以下说法正确的是：
  结果不正确，因为会溢出，用位与的方式就没问题
  结果正确，即使会溢出
  结果正确，不会溢出
  其他选项都不对
  
  
  15以下程序的运行结果是：

int main(void){
 int m=5;
 if(m++>5)cout<<m<<endl;
 else cout<<--m;
}

• 4
  5
  7
  6
  
  
  16对两个字符a和b进行初始化:
  char a[]="ABCDEF";
  char b[]={'A','B','C','D','E','F'};
  则以下叙述正确的是：
  a数组比b数组长度长
  a与b长度相同
  a与b数组完全相同
  a和b中都存放字符串
  用字符串方式赋值比用字符逐个赋值要多占一个 字节 ， 用于存放字符串结束标志'\0'
  
  17在一个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()程序的执行结果为（）
  1，0，0
  1，1，0
  0，1，1
  0，0，1
  结构体每个成员相对结构体首地址的偏移量(offset)都是每个成员本身大小的整数倍
  
  18 定义char dog[]="wang\0miao";那么sizeof(dog)与strlen(dog)分别是多少：
  10,4
  4,4
  9,9
  9,4

sizeof返回数组所占的字节数，'wang' 'miao'共占8字节，显式'\0'占1字节，字符串末尾隐式'\0'占1字节，共10字节。

strlen返回字符串的长度，以遇到'\0'结束符为准，因此为4。

• 
  19 C++中以下关于函数调用的说法哪个是正确的？
  传地址后实参和形参指向不同的对象
  传引用后实参和形参是不同的对象
  传值后对形参的修改会改变实参的值
  其他三项都不对
  
  
  20 以下系统中，int类型占几个字节，指针占几个字节，操作系统可以使用的最大内存空间是多大：
  32位下：4,4,2^32     64位下：8,8,2^64
  32位下：4,4,不限制   64位下：4,8,不限制
  32位下：4,4,2^32     64位下：4,8,2^64
  32位下：4,4,2^32     64位下：4,4,2^64
  
  
  21 C++中关于堆和栈的说法，哪个是错误的:
  堆的大小仅受操作系统的限制，栈的大小一般一般较小
  在堆上频繁的调用new/delete容易产生内存碎片，栈没有这个问题
  堆和栈都可以静态分配
  堆和栈都可以动态分配
  
  
  22Linux下多少个"-"将被打印：

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

• 16
  30
  32
  15

i=0时，主进程和其创建的子进程分别打印'-',  打印2个

i=1时，之前两个进程打印'-', 每个进程又创建新的子进程， 共打印4个'-'

i=2时，之前的四个进程分别打印'-', 并创建新的子进程, 故共打印8个'-'

i=3时，之前的8个进程分别打印'-', 并创建新的子进程,故共打印16个'-'

综上所述, 共打印2+4+8+16=30个

• 
  23 代码生成阶段的主要任务是：
  把高级语言翻译成机器语言
  把高级语言翻译成汇编语言
  把中间代码变换成依赖具体机器的目标代码
  把汇编语言翻译成机器语言
  
  
  24下面代码的执行结果是什么：

char ccString1[]="Is Page Fault??";
char ccString2[]="No Page Fault??";
strcpy(ccString1,"No");
if(strcmp(ccString1,ccString2)==0)
   cout<<ccString2;
else
   cout<<ccString1;

• No
  No Page Fault??
  Is Page Fault??
  其他三项都错
  
  
  25以下代码共调用多少次拷贝构造函数：

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

• 1
  3
  5
  7
  
  
  26下面C程序的输出结果:

int i=0,a=1,b=2,c=3;
i=++a||++b||++c;
printf("%d %d %d %d",i,a,b,c);

• 1 2 2 3
  1 2 3 4
  3 2 3 4
  3 3 3 4