2017昆仑万维技术类基础笔试题

1.为了避免头文件重复包含一般采用什么方法？

http://blog.csdn.net/xhfight/article/details/51550446

2.在c++程序中调用被C编译器编译后的函数，为什么要加extern “C”声明？

http://blog.chinaunix.net/uid-23028407-id-1992460.html

3.下面程序运行结果

#include <iostream>
#include<string.h>
using namespace std;
void func(char str[])
{
	cout << sizeof(str) << endl;
}

typedef union {
	char a; 
	short b;
	int c;  
	float d;  //4字节 
}A;

typedef struct {
	char a;
	char b;
	int c;
}B;

typedef struct {
	char a;
	int b; //4字节 
	char c;
}C;

int main() 
{
	char str[] = "test";
	cout << sizeof(str) << endl;
	func(str);
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	cout << sizeof(C) << endl;
}

答案：

解析：

第一个sizeof是求取内存，包含结束字符\0，所以输出4+1=5

第二个数组作为函数参数传递，退化为指针，32位情况下，指针大小为4

第三个union是取最大的那个内存，float位4个字节

第四个两个char放一个4字节对齐就够了，剩下一个4字节，4+4=8

第五个3个都要分开放了，4+4+4=12,

4.下面程序运行结果

class CTest
{
	public:
		CTest(const char* str)
		{
			strcpy(name,str);
			cout<< "constructor for " << name <<endl; 
		}
		CTest(const CTest& arg)
		{
			strcpy(name,arg.name);
			cout << "copy constructor for " << name <<endl;
		}
		~CTest()
		{
			cout << "destructor for " << name << endl;
		}
		private:
			char name[20];
};
CTest foo(CTest arg)
{
 	 CTest localObject("local");
	 static CTest staticObject("static");
	 return localObject; 
}
CTest g_globalobj("global");  //这个应该优先输出来，在主函数之前，调用构造函数，constructor for global 
int main()
{
	CTest a("a");  //constructor for a 
	CTest* b = new CTest("b");  // 构造函数，constructor for b 
	CTest c = foo(a);
	//copy constructor for a; 函数参数是类CTest的对象，所以会调用拷贝函数 
	//constructor for local; 
	//constructor for static;
	//copy constructor for local; 函数的返回值类型是类CTest的对象，调用拷贝构造函数
	//destructor for local; 函数调用完成，局部变量析构优先，因为函数参数一般处于函数调用者的栈帧上，
	//而函数内部的局部变量处在本函数对应的栈帧上，是位于不同的栈上的，
	//我通过反汇编查看也是发现传入参数和函数内局部变量的栈是不同的，
	//故函数一结束先清空函数的栈，再清空传入参数的栈。
	//destructor for a; 析构传入的参数
	delete b;//destructor for b  
	//最后的a和c对象，根据入栈先后，c后入栈，先析构，而后a析构
	//destructor for local
	//destructor for a
	//destructor for static; 在main结束后，静态对象就析构
	//destructor for global; 最后函数执行完毕全局对象析构
}

答案：

constructor for global
constructor for a
constructor for b
copy constructor for a
constructor for local
constructor for static
copy constructor for local
destructor for local
destructor for a
destructor for b
destructor for local
destructor for a
destructor for static
destructor for global

解析：

http://bbs.csdn.net/topics/392034471

5.下面程序运行结果

class CObject
{
public:
	CObject(){
		cout << "CObject::CObject()" << endl;
	}
	virtual ~CObject(){
		cout << "CObject::~CObject" << endl;
	}
	virtual void Serialize(){
		cout << "CObject::Serialize()" <<endl;
	}
};

class CDocument:public CObject
{
public:
	int m_data1;
	CDocument(){
		cout << "CDocument::CDocument()" << endl;
	}
	~CDocument(){
		cout << "CDocument::~CDocument()" << endl;
	}
	void func(){
		cout << "CDocument::func()" << endl;
		Serialize();
	}
	void Serialize(){
		cout << "CDocument::Serialize()" << endl;
	}
};

class CMyDoc:public CDocument
{
public:
	int m_data2;
	CMyDoc(){
		cout<< "CMyDoc::CMyDoc()" << endl;
	}
	~CMyDoc(){
		cout<< "CMyDoc::~CMyDoc()" << endl;
	}
	void Serialize(){   
		//这个函数隐藏了父类的函数，
		//所以执行的都是这个，隐藏：分参数同和不同，不同：不管有无virtual，都被隐藏；
		//相同，没有virtual，也被隐藏；有的话退化为重写了（只是他返回值没有管和重载一样）
		cout << "CMyDoc::Serilize()" << endl;
	}
};

void main()
{
	cout << "11111111111111111" <<endl;
	CDocument* pDoc = new CMyDoc;  //基类依次构造，最后是派生类
	cout << "22222222222222222222" <<endl;
	pDoc->func();
	cout << "33333333333333333333" <<endl;
	delete pDoc;
	cout << "444444444444444444444" <<endl;
	CMyDoc mydoc;
	cout << "55555555555555555555555" <<endl;
	mydoc.func();
	cout << "66666666666666666666666" <<endl;
	((CDocument*)(&mydoc))->func();
}

答案：

11111111111111111
CObject::CObject()
CDocument::CDocument()
CMyDoc::CMyDoc()
22222222222222222222
CDocument::func()
CMyDoc::Serilize()
33333333333333333333
CMyDoc::~CMyDoc()
CDocument::~CDocument()
CObject::~CObject
444444444444444444444
CObject::CObject()
CDocument::CDocument()
CMyDoc::CMyDoc()
55555555555555555555555
CDocument::func()
CMyDoc::Serilize()
66666666666666666666666
CDocument::func()
CMyDoc::Serilize()
CMyDoc::~CMyDoc()
CDocument::~CDocument()
CObject::~CObject

解析：
主要考察了：

1.派生类对象的构造顺序，先调用最顶层的基类默认构造函数，最后才到自己

2.析构的顺序，先析构派生类的，最后是基类的

3.函数重载，重写，和重定义的区别的利用，这里主要考察了重定义这个用法，调用的是派生类的函数

6.单链表的翻转；链表排序？（忘了）

主要代码如下：

pNode = pHead;
pPre = NULL;
while (pNode != NULL)
{
	pNext = pNode->next;
	pNode->next = pPre;
	pPre = pNode;
	pNode = pNext;
}

解析：

让当前节点的指向下一个节点存储上前一个，这样就翻转过来了

pNext是为了移位时候，顺利保存下一个节点指针用的

2017昆仑万维技术类基础笔试题

猜你喜欢