土豆春季实习试题之惨烈教训

今天做土豆的春季C++实习生招聘试题，很多不应该错的错了，在此挑出一些重要的错误，供自己参考，以免以后再犯。

一、一道编程题，很简单，但是错了。

题目：

   输入一个数组，求它的逆序数组。如输入： 1 2 3 4，输出 4 3 2 1

它给出了框架，让填写部分代码：

#include<iostream>
#include <vector>
#include <string>
using namespace std;
class  example
{
public:
	static const vector<int>& reverse1(const vector<int>& r)
	{
		vector<int>  temp(r.begin(),r.end());
		vector<int>::iterator vbegin=temp.begin();
		vector<int>::iterator vend=temp.end()-1;
		while(vbegin<vend)
		{
			swap(*vbegin++,*vend--);
		}
		static const vector<int> temp2(temp.begin(),temp.end());
		return temp2;
	}
protected:
private:
};
void main()
{
	int d[]={1,2,3,4,5};
	vector<int> f(d,d+5);

	const vector<int> s=example::reverse1(f);
   copy(s.begin(),s.end(),ostream_iterator<int>(cout," "));
}

在上述的代码中，要注意以下几点：

1.

vector<int>::iterator vend=temp.end()-1;

一定要注意temp的最后一个元素是end()-1,而不是end()，end()指向量中最后一个元素的下一个元素。

2.当返回类型是指针或引用时，必须强调使用static局部变量，否则使用普通的局部变量，一旦函数调用结束，变量就会释放掉，使得指针或引用指向不确定的对象。

3.静态成员函数，可以直接使用类名直接调用。

二、

   int i=001+010+100;
   cout<<i<<endl;

输出结果: 109

分析：

001,010 都是以0开头的8进制数，分别等于1，8，因此上式等于109

举一反三：

  int i=0x001+0x010+100;
   cout<<i<<endl;

输出结果: 117

分析：

0X001,0X010 都是以0x开头的16进制数，分别等于1，16，因此上式等于117

三、

编程题：

对于一个数字A，它的“DA（DA为一位整数）”数PA为A中所有DA拼成的数。例如1566的PA数为66，因为它有两个6。现在有两个数A和B，DA分别是DA1和DA2，求解A和B的PA书PA1+PA2?  0<A,B<10^30

例如 A:1566，DA1=6;于是PA1=66

B:4231554，DA2=5;于是PA2=55,PA1+PA2=66+55=121

由于A,B的范围较大，实际上已经超过了long long 的范围，所以属于大数据相加。

#include<iostream>
#include <vector>
#include <string>
using namespace std;
class example
{
public:
	static const string& calc(const string& stra,unsigned int a,const string& strb,unsigned int b)//这里a,b为一位整数
	{
	 int count_a=0;
	 int count_b=0;
	 int i=0,j=0;

		//计算stra中有多少个a
		for(string::const_iterator vbegin=stra.begin();vbegin!=stra.end();++vbegin)
		{
			if ((*vbegin-'0')==a)
			{
				count_a++;
			}
		}
		//计算strb中有多少个b
		for(string::const_iterator vbegin=strb.begin();vbegin!=strb.end();++vbegin)
		{
			if ((*vbegin-'0')==b)
			{
				count_b++;
			}
		}
		 int na=count_a;
		 int nb=count_b;
		int length=na>nb?na:nb;
		int* pa=new int[length+1];//由于stra可能都是a组成的，一旦相加有可能越位。
		int* pb=new int[length+1];
		memset(pa,0,(length+1)*sizeof(int));
		memset(pb,0,(length+1)*sizeof(int));
		//计算pa
		while (count_a--)
		{
			pa[i++]=a;
		}
		//计算pb
		while (count_b--)
		{
			pb[j++]=b;
		}
	
		for (int i=0;i<length;i++)
		{
			pa[i]=pa[i]+pb[i];
		}
		int ncount=0;//相加的两个数的最终位数
       for (int i=0;i<length;i++)
       {
		   if (pa[i]>9)
		   {
			   int temp=pa[i]/10;
			   pa[i+1]+=temp;
			   pa[i]=pa[i]%10;
              ncount=length;
		   }
		   else
		   {
                ncount=length-1;
		         continue;
		   }
       }
     //至此pa就是最后的结果，但是pa是反着的。可以参考我的博客：<a target=_blank href="http://blog.csdn.net/xiamentingtao/article/details/46362577">http://blog.csdn.net/xiamentingtao/article/details/46362577</a>
		static string s1;
		//整数转字符串
		for (int i=ncount;i>=0;i--)
		{
			char s=pa[i]+'0';
			s1.append(1u,s);//string& append (size_t n, char c);
		}
		delete[] pa;
		pa=NULL;
		delete[] pb;
		pb=NULL;
		return  s1;
	}
protected:
private:
};


void main()
{
	const string vi=example::calc("12455555555555555555555555555",5,"45666666666666666666666666666666666666666666666666112",6);

}

四、不能被重载为类的成员运算符的是哪些运算符？

 1. 并不是所有的操作符都能被重载。除了. ，.* ，:: ，? : ，sizeof，typeid这几个运算符不能被重载，其他运算符都能被重载
 2.  重载不能改变该运算符用于内置类型时的函义，程序员不能改变运算符+用于两个int型时的含义。
3.  运算符函数的参数至少有一个必须是类的对象或者类的对象的引用。这种规定可以防止程序员运用运算符改变内置类型的函义。
8.4 重载不能改变运算符的优先级。
8.5 重载不能改变运算符的结合律。
8.6 重载不能改变运算符操作数的个数。比如+需要两个操作数，则重载的+也必须要有两个操作数。