有时失去不是忧伤,而是一种美丽.
当我们学会用积极的心态去对待"放弃"时,我们将拥有"成长"这笔巨大的财富!–村上春树

1.用变量a给出下面的定义:
一个有10个指针的数组,该指针指向一个函数,该函数有一个整形参数并返回一个整型数

A int *a[10]; 		B int (*a)[10]; 	
C int (*a)(int); 	D int (*a[10])(int);
正确答案：D

解析:
A为指针数组,B为数组指针,C为函数指针,D为函数指针数组

2.对于int pa[5];的描述，以下哪个选项是正确的（）*

A pa是一个具有5个元素的指针数组，每个元素是一个int类型的指针; 
B pa是一个指向数组的指针，所指向的数组是5个int类型的元素; 
C pa[5]表示某个数的第5个元素的值; 
D pa是一个指向某个数组中第5个元素的指针，该元素是int类型的变量
正确答案：A

3.下列程序执行后,输出的结果为()

#include<stdio.h> 
int cnt=0; 
int fib(int n){    
	cnt++;    
	if(n == 0){
		return 1;
	}  
	else if(n ==1){
			return 2;
	}
	else{
	return fib(n-1)+fib(n-2);
	}        
} 
void main(){   
	fib(8);   
	printf("%d",cnt); 
}

A 41 	B 67 	C 109 	D 177
正确答案：B

解析:
此题考察递归调用,总共调用67次;

4.以下C语言指令：

int a[5] = {1,3,5,7,9}; 
int *p = (int *)(&a+1); 
printf(“%d,%d”,*(a+1)，*(p-1));
运行结果是什么？
A 2,1 	B 3,1 	C 3,9 	D 运行时崩溃
正确答案：C

5.以下哪个选项一定可以将flag的第二个bit置0

A flag&=~2 	B flag|=2 	C flag^=2 	D flag>>=2
正确答案：A

6.print()函数是一个类的常成员函数，它无返回值，下列表示中正确的是()

A const void print(); 	B void const print(); 
C void print() const; 	D void print(const);
正确答案：C

7.以下关于纯虚函数的说法,正确的是()

A 声明纯虚函数的类不能实例化 	B 声明纯虚函数的类成虚基类 
C 子类必须实现基类的 			D 纯虚函数必须是空函数
正确答案：A

8.下列有关this指针使用方法的叙述正确的是（）

A 保证基类保护成员在子类中可以被访问 	
B 保证基类私有成员在子类中可以被访问 
C 保证基类共有成员在子类中可以被访问 
D 保证每个对象拥有自己的数据成员，但共享处理这些数据的代码
正确答案：D

解析:
3.9 this指针
3.9.1 this指针的引出
C++编译器给每个“成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
3.8.2 this指针的特性
（1）this指针的类型：类类型* const ；
（2）只能在“成员函数”的内部使用 ；
（3） this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针；
（4）this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

9.下列情况中，不会调用拷贝构造函数的是（）

A 用一个对象去初始化同一个类的另一个新对象时 
B 将类的一个对象赋值给该类的另一个对象时 
C 函数的形参对象，调用函数进行形参和实参结合时 
D 函数的返回值是类的对象，函数执行返回调用时
正确答案：B

解析:
4.4 拷贝构造函数
4.4.1 定义
只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象 创建新对象时由编译器自动调用。
4.3.2 特性
（1）拷贝构造是特殊的成员函数；
（2） 拷贝构造函数是构造函数的一个重载形式~；
（3） 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用；
（4）若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝；
10.下面程序输出结果是什么?

#include<iostream> 
using namespace std;

class A{
public: 
	A(char *s){
		cout << s << endl;
	}
	~A()
	{}
};

class B :virtual public A{
public: 
	B(char *s1, char*s2) :A(s1){
		cout << s2 << endl;
	}
};

class C :virtual public A {
public: 
	C(char *s1, char*s2) :A(s1){
		cout << s2 << endl;
	}
};

class D :public B, public C {
public: 
	D(char *s1, char *s2, char *s3, char *s4) :
	B(s1, s2), C(s1, s3), A(s1) {
		cout << s4 << endl;
	}
};

int main() {
	D *p = new D("class A", "class B", "class C", "class D");
	delete p; 
	system("pause");
	return 0;
}

A 	class A class B class C class D 
B 	class D class B class C class A 
C 	class D class C class B class A 
D 	class A class C class B class D

正确答案：A