笔试题目搜集系列推荐：
（1）笔试题目搜集1
（2）笔试题目收集2
（3）笔试题目搜集3
（4）笔试题目搜集4
（5）笔试题目搜集5
1.下列程序输出结果
typedef union {long i; int k[5]; char c;} DATE;
struct data {
char cat;
DATE cow;
char dog;
};
cout<<sizeof(data)<<endl;
date按照4来对界，所以data结构体中按照最大的类型4来对界。最后结果28
2.运行下图中的C++代码，打印出的结果是什么？
bool Fun1(char* str)
{
printf("%s\n", str);
return false;
}
bool Fun2(char* str)
{
printf("%s\n", str);
return true;
}
int _tmain(int argc, _TCHAR* argv[])
{
bool res1, res2;
res1 = (Fun1("a") && Fun2("b")) || (Fun1("c") || Fun2("d"));
res2 = (Fun1("a") && Fun2("b")) && (Fun1("c") || Fun2("d"));
return res1 || res2;
}
答案：打印出4行，分别是a、c、d、a。
3.编译运行下图中的C++代码，结果是什么？（A）编译错误；（B）编译成功，运行时程序崩溃；（C）编译运行正常，输出10。请选择正确答案并分析原因。（题目出自海涛:http://zhedahht.blog.163.com/blog/static/2541117420111169592105/）
#include <iostream>
class A
{
private:
int value;
public:
A(int n)
{
value = n;
}
A(A other)
{
value = other.value;
}
void Print()
{
std::cout << value << std::endl;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
A a = 10;
A b = a;
b.Print();
return 0;
}
答案
：编译错误。在复制构造函数中传入的参数是
A
的一
个实例。由于是传值，把形参拷贝到实参会调用复制构造函数。因此如果允许复制构造函数传值，那么会形成永无休止的递归并造成栈溢出。因此
C++
的标准不允许复制构造函数传值参数，而必须是传引用或者常量引用。在
Visual Studio
和
GCC
中，都将编译出
错。
4.运行下图中代码，输出的结果是什么？这段代码有什么问题？
#include <iostream>
class A
{
public:
A()
{
std::cout << "A is created." << std::endl;
}
~A()
{
std::cout << "A is deleted." << std::endl;
}
};
class B : public A
{
public:
B()
{
std::cout << "B is created." << std::endl;
}
~B()
{
std::cout << "B is deleted." << std::endl;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
A* pA = new B();
delete pA;
return 0;
}
答案：输出三行，分别是：A is created. B is created. A is deleted。用new创建B时，回调用B的构造函数。在调用B的构造函数的时候，会先调用A的构造函数。因此先输出A is created. B is created.
接下来运行delete语句时，会调用析构函数。由于pA被声明成类型A的指针，同时基类A的析构函数没有标上virtual，因此只有A的析构函数被调用到，而不会调用B的析构函数。
由于pA实际上是指向一个B的实例的指针，但在析构的时候只调用了基类A的析构函数，却没有调用B的析构函数。这就是一个问题。如果在类型B中创建了一些资源，比如文件句柄、内存等，在这种情况下都得不到释放，从而导致资源泄漏。
5.运行如下的C++代码，输出是什么？（转自：http://zhedahht.blog.163.com/blog/static/254111742011299219769/）
class A
{
public:
virtual void Fun(int number = 10)
{
std::cout << "A::Fun with number " << number;
}
};
class B: public A
{
public:
virtual void Fun(int number = 20)
{
std::cout << "B::Fun with number " << number;
}
};
int main()
{
B b;
A &a = b;
a.Fun();
}
答案：输出B::Fun with number 10。由于a是一个指向B实例的引用，因此在运行的时候会调用B::Fun。但缺省参数是在编译期决定的。在编译的时候，编译器只知道a是一个类型a的引用，具体指向什么类型在编译期是不能确定的，因此会按照A::Fun的声明把缺省参数number设为10。
这一题的关键在于理解确定缺省参数的值是在编译的时候，但确定引用、指针的虚函数调用哪个类型的函数是在运行的时候
6.运行下图中C代码，输出的结果是什么？（转自：http://zhedahht.blog.163.com/blog/static/254111742011299219769/）
int _tmain(int argc, _TCHAR* argv[])
{
char str1[] = "hello world";
char str2[] = "hello world";
char* str3 = "hello world";
char* str4 = "hello world";
if(str1 == str2)
printf("str1 and str2 are same.\n");
else
printf("str1 and str2 are not same.\n");
if(str3 == str4)
printf("str3 and str4 are same.\n");
else
printf("str3 and str4 are not same.\n");
return 0;
}
答案：输出两行。第一行是str1 and str2 are not same，第二行是str3 and str4 are same。
str1和str2是两个字符串数组。我们会为它们分配两个长度为12个字节的空间，并把"hello world"的内容分别拷贝到数组中去。这是两个初始地址不同的数组，因此比较str1和str2的值，会不相同。str3和str4是两个指针，我们无需为它们分配内存以存储字符串的内容，而只需要把它们指向"hello world“在内存中的地址就可以了。由于"hello world”是常量字符串，它在内存中只有一个拷贝，因此str3和str4指向的是同一个地址。因此比较str3和str4的值，会是相同的。
7.运行下面的代码，输出是什么？（之前始终不知道为什么是1，哈哈，何老师给了我答案）（转自：http://zhedahht.blog.163.com/blog/static/254111742011012111557832/）
class A
{
};
class B
{
public:
B() {}
~B() {}
};
class C
{
public:
C() {}
virtual ~C() {}
};
int _tmain(int argc, _TCHAR* argv[])
{
printf("%d, %d, %d\n", sizeof(A), sizeof(B), sizeof(C));
return 0;
}
分析：答案是1, 1, 4。class A是一个空类型，它的实例不包含任何信息，本来求sizeof应该是0。但当我们声明该类型的实例的时候，它必须在内存中占有一定的空间，否则无法使用这些实例。至于占用多少内存，由编译器决定。Visual Studio 2008中每个空类型的实例占用一个byte的空间。
class B在class A的基础上添加了构造函数和析构函数。由于构造函数和析构函数的调用与类型的实例无关（调用它们只需要知道函数地址即可），在它的实例中不需要增加任何信息。所以sizeof(B)和sizeof(A)一样，在Visual Studio 2008中都是1。
class C在class B的基础上把析构函数标注为虚拟函数。C++的编译器一旦发现一个类型中有虚拟函数，就会为该类型生成虚函数表，并在该类型的每一个实例中添加一个指向虚函数表的指针。在32位的机器上，一个指针占4个字节的空间，因此sizeof(C)是4。
8.运行下面中的代码，得到的结果是什么？（转自：http://zhedahht.blog.163.com/blog/static/254111742011299219769/）
class A
{
private:
int m_value;
public:
A(int value)
{
m_value = value;
}
void Print1()
{
printf("hello world");
}
void Print2()
{
printf("%d", m_value);
}
virtual void Print3()
{
printf("hello world");
}
};
int _tmain(int argc, _TCHAR* argv[])
{
A* pA = NULL;
pA->Print1();
pA->Print2();
pA->Print3();
return 0;
}
答案：Print1调用正常，打印出hello world；但运行至Print2时，程序崩溃；运行Print3时，程序也会崩溃
分析：调用Print1时，并不需要pA的地址，因为Print1的函数地址是固定的。编译器会给Print1传入一个this指针，该指针为NULL，但在Print1中该this指针并没有用到。只要程序运行时没有访问不该访问的内存就不会出错，因此运行正常。在运行print2时，需要this指针才能得到m_value的值。由于此时this指针为NULL，因此程序崩溃了。
由于Print3是虚函数。C++调用虚函数的时候，要根据实例（即this指针指向的实例）中虚函数表指针得到虚函数表，再从虚函数表中找到函数的地址。由于这一步需要访问实例的地址（即this指针），而此时this指针为空指针，因此导致内存访问出错。
9.运行如下的C代码，输出是什么？（转自：http://zhedahht.blog.163.com/blog/static/254111742011299219769/）
char* GetString1()
{
char p[] = "Hello World";
return p;
}
char* GetString2()
{
char *p = "Hello World";
return p;
}
int _tmain(int argc, _TCHAR* argv[])
{
printf("GetString1 returns: %s. \n", GetString1());
printf("GetString2 returns: %s. \n", GetString2());
return 0;
}
答案：输出两行，第一行GetString1 returns: 后面跟的是一串随机的内容，而第二行GetString2 returns: Hello World. 两个函数的区别在于GetString1中是一个数组，而GetString2中是一个指针。
当运行到GetString1时，p是一个数组，会开辟一块内存，并拷贝"Hello World"初始化该数组。接着返回数组的首地址并退出该函数。由于p是GetString1内的一个局部变量，当运行到这个函数外面的时候，这个数组的内存会被释放掉。因此在_tmain函数里再去访问这个数组的内容时，结果是随机的。（栈空间分配的，所以函数调用结束后释放掉）
当运行到GetString2时，p是一个指针，它指向的是字符串常量区的一个常量字符串。该常量字符串是一个全局的，并不会因为退出函数GetString2而被释放掉。因此在_tmain中仍然根据GetString2返回的地址得到字符串"Hello World"。
10.下面程序运行的结果（非常经典）
#include"iostream"
using namespace std;
class A{
public:
A() {
func(0);
};
virtual void func(int data) {printf("A1 :%d\n",data);}
virtual void func(int data) const {printf("A2 :%d\n",data);}
void func(char *str) {printf("A3 %s\n",str);}
};
class B:public A{
public:
void func() {printf("B1 :%s\n","");}
void func(int data) {printf("B2 :%d\n",data);}
void func(char *str) {printf("B3 %s)\n",str);}
};
int main()
{
A *pA; //没有new对象，不调用构造函数
B b; //调用构造函数
const A *pcA;
pA=&b;
pA->func(1);
pA->func("test");
A().func(1);
pcA=&b;
pcA->func(2);
system("pause");
return 0;
}
运行结果：
