笔试题目收集(2)

笔试题目搜集系列推荐：

（1）笔试题目搜集1

（2）笔试题目收集2

（3）笔试题目搜集3

（4）笔试题目搜集4

（5）笔试题目搜集5

1.下列程序运行的结果：（面试宝典P108）

#include<iostream>
#include<string>

using namespace std;

class classType{
private:
	int x,y;
public:
	classType(int a):y(a),x(y)
	{}
	int getx(){return x;}
	int gety(){return y;}
};


int main()
{
    classType obj(98);
	cout<<obj.getx()<<" "<<obj.gety()<<endl;
	getchar();
	return 0;
}

结果：输出结果第一个数为随机数，第二个数为98。

分析：类中先声明x，后声明y，所以在初始化成员变量时先初始化x，再初始化y的顺序。将上面改为int y，x，得到预期的输出，即98 98。

2.指出下面程序的错误，把静态成员数据声明为私有，该如何访问？

class A{
    const int size=0;
};

错误：上面的错误应该是没有定义性说明。

方法1：

class A{
    static const int size;
};
int A::size = 0;

其实也可以这样：（为什么？参见博客http://blog.csdn.net/lsjseu/article/details/9071285静态成员第四条）

class A{
    static const int size=0;//这是一种例外
};
int A::size;

      类中的成员声明不能赋初值（静态成员除外，且静态成员在定义性说明的时候赋初值，如果不赋初值则取默认值，但是必须要定义性说明），因为类只是一种导出的类型，不分配空间。

方法2：

class A{
    const int size;
    A():size(0){}//const变量必须在初始化列表中
};

      静态成员设为私有只能通过静态的成员函数访问。

3.数组循环移位

解法1：

RightShift(int *arr,int N,int K)
{
   K%=N;
   while(k--){
     int t=arr[N-1];
     for(int i=N-1;i>0;i--)
         arr[i]=arr[i-1];
     arr[0]=t;
    }

}

解法2：

Reverse(int *arr,int b,int e)
{
	K%=N;
    for(;b<e;b++,e--){          //字符串反序的时候可以用这个代码
         int tmp = arr[b];
         arr[b] = arr[e];
         arr[e] = tmp;
   }
}
RightShift(int *arr,int N,int K)
{
     K%=N;
     Reverse(arr,0,N-K-1);
     Reverse(arr,N-K,N-1);
     Reverse(arr,0,N-1);
}

4.插入排序、选择排序和冒泡排序代码（上次去阿里笔试，插入排序还写错了，丢人，这次一定要狠心记住）

插入排序：

void InsertionSorter(int *arr,int len)
{
	for(int i=1;i<len;i++){
		int t = arr[i];
		int j = i;
		while(j>0&&arr[j-1]>t){
			arr[j] = arr[j-1];
			j--;
		}
		arr[j] = t;
	}
}

选择排序：

void SelectionSorter(int *arr,int len)
{
	for(int i=0;i<len-1;i++){
		int k = i;
		for(int j = i+1;j<len;j++){
			if(arr[j] < arr[k]) k = j;
		}
		if(k!=i)
		{
			int t = arr[k];
			arr[k] = arr[i];
			arr[i] = t;
		}
	}
}

冒泡排序：

void BubbleSorter(int *arr,int len)
{
	for(int i=0;i<len-1;i++){
		bool flag = false;
		for(int j = 0;j<len-i-1;j++){
			if(arr[j]>arr[j+1]){
				int tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
				flag = true;
			}
		}
        if(!flag)break;  
	}
}

5.析构函数设为virtual有什么作用，构造函数为什么不能设为虚函数？《面试宝典P109》

（1）构造函数为什么不能设为虚函数：虚函数是一种虚调用的方法，这种调用运行我们知道接口而不知道具体类型。但是是定义类的时候，我们势必要知道准确类型，因此构造函数不能为虚函数。

（2）析构函数有时候为什么需要定义为虚函数：

例子：

class Base{
public: 
      ~Base(){...}
}

class Derived:public Base{
public:
       ~Derived(){..}
}

void main()
{
	Base *pBase;
    Derived dev;
    pBase=dev;
}

       如果基类的的析构函数~Base(){...}不是虚函数，则撤销pBase时，将不会调用 ~Derived()，从而就不会释放  Derived::Derived()占据的内存，造成内存泄露。相反，如果将~Base()定义为虚函数，由Base派生的类将自动变为虚函数，这样在pBase撤销时，会先调用~Derived类析构函数，再调用~Base析构函数。

6.string &string::operator(const string& other)中的const的作用?《面试宝典P113》

答：一是避免修改other对象；二是加入const关键字，const 对象才能调用operator操作符。因为在C++有如下调用关系：

                     

意思：const只能调用参数为const的函数，非const能调用参数为const或者非const的函数； 参数为const的函数能被const变量或者非const变量调用，非const参数的函数只能被非const变量调用

那么如果string &string::operator(const string& other)不加const关键字，如下调用就会有问题：

String s3("hello");
const String s4("word");
s3=s4;//这句话就因为s4是const变量而不能调用参数为非const的函数。

7.下列程序运行结果

#include<iostream>

using namespace std;

class A{
public:
   int m_nA;
};

class B{
public:
   int m_nB;
};

class C:public A,public B{
public:
   int m_nC;
};

int main()
{
    C *pC = new C;
    //这里C是从继承类型转换为指向基类性的指针，不需要有虚继承
    B *pB = dynamic_cast<B*>(pC);

    if(pC==pB)cout<<"equal"<<endl;                //A
    else cout<<"not equal"<<endl;

    if(int(pC)==int(pB))cout<<"equal"<<endl;      //B
    else cout<<"not equal"<<endl;

    if(int(pC)==int((C*)pB))cout<<"equal"<<endl;  //C
    else cout<<"not equal"<<endl;
    return 0;
}

运行结果：equal 、not equal 、 equal

         //A :这两端数据类型不同比较时会进行隐式转换。pC==pB相当于pC==(C*)pB。pB=dynamic_cast<B*>(pC)实际上指向的C对象中的子类B部分，从地址上跟pC不一样,所以直接比较地址的数值肯定不相等，即//B句输出“Not equal”。但是如果将(C*)pB转换为pC直向的地址，这是pB也指向了PC指向的部分。即两者就相等了，数值上也相等。//A和//C输出“equal”。

8.虚函数的入口地址和普通函数有什么不同。

答：每个虚函数在vtable（虚表）中占了一个表项，保存着一条跳转到它的入口地址的指令（实际上就是保存了入口地址）。当包含虚函数对象被创建的时候，它在头部附加一个指针，指向vtable中相应的位置（用sizeof的时候需要注意了）。调用虚函数的时候，不管你用什么指针调用的，它先根据vtable找到入口地址再执行，从实现了“动态绑定”，而不像普通函数哪样简单地跳转到一个固定地址。

9.下列代码输出结果

void main()
{
	int *pa = NULL;
    int  *pb = pa + 15;
    printf("%x",pb);
}

输出：0+15*6=60=0x3c

union {
	unsigned char a;
    unsigned int i;
}
main(){
	u.i = 0xf0f1f2f3; 
    cout<<hex<<u.i<<endll
    cout<<hex<<(int)u.a<<endll
}

输出：fof1f2f3    f3。内存数据低位字节存入低地址，高位字节存入高地址

10、设有以下说明和定义：

　    typedef union {long i; int k[5]; char c;} DATE;

　　struct data { int cat; DATE cow; double dog;} too;

　　DATE max;

　　则语句 printf("%d",sizeof(struct date)+sizeof(max));的执行结果是：___52____

　　答：DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20

　　data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32。（这里没有按照20对界，而是按照doule类型对界。因为int k[5]是数组，对界还是按照元素类型int对界，即按照4来对界。这样结构data中最大的类型就是double，即按照8来对整个结构体来对界）

　　所以结果是 20 + 32 = 52。