C++笔试题深度分析 第三波 上

1. 下面的代码输出什么？为什么？
#include <iostream>
#include <malloc.h>
using namespace std;
class A
{
private:
static int c_count;
public:
A()
{
c_count++;
}
~A()
{
c_count--;
}
static void Count()
{
cout<<c_count<<endl;
}
};
int A::c_count = 0;
int main()
{
A* a = static_cast<A*>(malloc(sizeof(A)));
a->Count();
delete a;
a->Count();
return 0;
}

解释：

输出： 0 和 -1；

为什么不是1 和 0？

这里考点1：  malloc不会调用构造函数，delete会调用析构函数，所以第一个a->Count()为0；第二个调用析构函数后为-1；

考点2： 为什么调用delete后还能利用a->count()这样的语句？

因为在C++中调用静态成员只使用类型，这里a->count()当中的a只是告诉编译器是A类型的相当于调用A::count();

 

2. 下面的代码输出什么？为什么？
class A
{
public:
virtual void test(int i)
{
cout<<"A::test"<<i<<endl;
}
void test()
{
cout<<"A::test"<<endl;
}
};
class B : public A
{
public:
void test(double i)
{
cout<<"B::test"<<i<<endl;
}
};
int main()
{
A* a = new B();
B* b = new B();
a->test(5);
b->test(5);
return 0;
}

解释：

输出：

A::test5
B::test5

 

为什么不是两个 B::test5?

因为这里

virtual void test(int i){cout<<"A::test"<<i<<endl;}与

void test(double i)
{
cout<<"B::test"<<i<<endl;
}
并没有发生重写，这里是简单的覆盖（隐藏），所以不会发生多态；

A*a = new B；

a->test（5）；

没有发生多态，发生多态的重写函数必须类型严格一致。

这里的考点就是：重写与多态！

 

3. 下面的描述正确的是（ ）
A. 面向对象编程需要面向对象语言的支持，如 Java 和 C++等。
B. 封装，继承和多态是面向对象的基本特征。
C. 继承是面向对象中代码复用的唯一方式。
D. 多态的工作方式与重载相同

 

解释：选B，C：组合也是；D：不是重载是重写；A：面向对象是一种思想，与哪种语言没关系，C语言是面向过程的语言，也可以加入面向对象的思想实现面向对象。

 

4. 下面的代码输出什么？为什么？
class A
{
private:
int i;
public:
virtual void test()
{
cout<<"A::test"<<endl;
}
};
class B : public A
{
private:
int i;
public:
void test()
{
cout<<"B::test"<<endl;
}
};
void f(A* p, int len)
{
for(int i=0; i<len; i++)
{
p[i].test();
}
}
int main()
{
B b[3];
f(b, 3);
return 0;
}

解释：

答案：输出一个B::test,然后程序死掉。

为什么程序死掉？

这里的考点是：多态遇上了数组：

A*p = b;

A类型的大小与Ｂ类型的大小不一样，明显Ｂ大于A；

p【i】.test = (p+i).test = (unsigned int)p +sizeof(p)*i

p+1 指向的内存不是 b【2】而是介于b【1】与b【2】直接的内存地址

所以多态遇上了数组，发生段错误，详细的请参考我的博文《当多态遇上了数组》。

 

5. 下面描述正确的是：（ ）
A. 一个应用程序启动后成为一个进程
B. 进程是操作系统分配资源的基本单位
C. 一个进程中可以创建多个线程，每个线程都共享进程的资源
D. 操作系统可以在创建进程的时不创建任何一个线程

 

解释：答案为 ABC

 

6. 下面程序输出什么？为什么？
class A
{
private:
static int i;
public:
A()
{
i++;
}
A(const A&)
{
i++;
}
static void output()
{
cout<<i<<endl;
}
};
A f(A& a)
{
A aa = a;
return a;
}
int A::i = 0;
int main()
{
A a;
f(a).output();
return 0;
}

解释：输出为3;

为什么是3呢？

Ａ　a；这里调用一次构造函数 i++ = 1；

f（a）参数这里因为传的是引用，所以没有调用构造函数

但是函数里面： A aa= a；等价于 A aa(a)调用了拷贝构造函数 i++ = 2；

return a； 这里要把 a的值赋值给一个临时变量对象；这里又要调用一次构造函数

i++ = 3；

所以为3；

把程序改一下：

{
private:
 static int i;
public:
 A()
 {
  cout<<"A()"<<endl;
  i++;
 }
 A(const A&)
 {
  cout<<"A(const A&)"<<endl;
  i++;
 }
 static void output()
 {
  cout<<i<<endl;
 }
};

 

输出：

A()
A(const A&)
A(const A&)
3

可见我们上面分析的是正确的！

 

7. 下面程序输出什么？为什么？
#include <iostream>
using namespace std;
#define FUNC(a, b) a = a + b; \
b = a - b; \
a = a - b
int main()
{
int a = 3;
int b = 4;
if(a > b) FUNC(a, b);
cout<<a<<" "<<b<<endl;
}

 

解释：输出 4，-1；

原因： 宏的副作用：进行宏替换后：

if（a>b）

a= a+b;

b= a-b;

a= a-b;

只有 a = a+ b;属于if语句的范围。