C++笔试题

1.多态类中的虚函数表是Compile-Time，还是Run-Time时建立的?

答案：虚拟函数表是在编译期就建立了,各个虚拟函数这时被组织成了一个虚拟函数的入口地址的数组.而对象的隐藏成员--虚拟函数表指针是在运行期--也就是构造函数被调用时进行初始化的,这是实现多态的关键.

 

3.main主函数执行完毕后，是否可能会再执行一段代码?（朗讯的一道笔试题）

答案：可以，可以用_onexit 注册一个函数，它会在main 之后执行;

如果你需要加入一段在main退出后执行的代码，可以使用atexit()函数，注册一个函数。   
  语法：   
  #include <stdlib.h> 
  int atexit(void  (*function")(void));   
  #include  <stdlib.h>  
  #include  <stdio.h>   
  void  fn1( void ),  fn2( void ),  fn3( void ),  fn4( void );     
  int  main( void )   
  {   
        atexit(fn1);   
        atexit( fn2 );   
        atexit( fn3 );   
        atexit( fn4 );   
        printf( "This is executed first.\n" );   
  }    
  void  fn1()   
  {   
        printf( "next.\n" );   
  }    
  void  fn2()   
  {   
        printf( "executed " );   
  }     
  void  fn3()   
  {   
        printf( "is " );   
  }     
  void  fn4()   
  {   
        printf( "This " );   
  }   

结果：

This   is   executed   first.   
 This   is   executed   next.  

4.一个父类写了一个virtual 函数，如果子类覆盖它的函数不加virtual ,也能实现多态? 

在子类的空间里，有没有父类的这个函数，或者父类的私有变量? (华为笔试题）

答案：只要基类在定义成员函数时已经声明了virtue关键字，在派生类实现的时候覆盖该函数时，virtue关键字可加可不加，不影响多态的实现。子类的空间里有父类的所有变量(static除外)。

5.给一个字符串、例如 “ababc”要求返回“ab”. 因为“ab”连续重复出现且最长。

  用C/C＋＋语言写一函数完成该算法，给出复杂度

如果有多个答案就返回第一个了
像：ababcdcd, 输出是就是ab了

复杂度分析：
i = 1
for (i to N)
{
 for (0 to N-i)
 {
 k = i
 for (0 to i) /* 字符串copy */
 }
}
O(N^3)

#include <iostream>
#include <string>
#include <map>
#include <algorithm>
using namespace std;

int main()
{
 string str, tmp, buf;
 int i, j, k, index, len, max;
 map<string, int> my_map;
 
 cout << "Enter a string:" << endl;
 cin >> str;
 
 len = str.size();
 for (k = 1; k <= len; k++) /* 长度为K的字符串 */
 {
 cout << "串长为" << k << ":" << endl;
 for (i = 0; i < len - k + 1; i++) /* 串长为K的字符串的开头 */
 {
 index = k;
 tmp = "";
 j = i;
 while (index--) /* 串长为j的 */
 {
 tmp += str[j++];
 }
 my_map[tmp]++; /* 收集 */
 cout << tmp << " ";
 }
 cout << endl;
 }
 
 len = str.size();
 max = -1;
 buf = "";
 for (k = 1; k <= len; k++) /* 长度为K的字符串 */
 {
 for (i = 0; i < len - k + 1; i++) /* 串长为K的字符串的开头 */
 {
 index = k;
 tmp = "";
 j = i;
 while (index--) /* 串长为j的 */
 {
 tmp += str[j++];
 }
 
 if ((max == -1 && my_map[tmp] > 1) /* mY_map[tmp] >1：连续重复 */
 || (my_map[tmp] > 1 && max < tmp.size())) /* max < ~.size()且最长 */
 {
 buf = tmp;
 max = tmp.size();
 }
 
 }
 }
 cout << endl << "应该返回的串是：\n" << buf << endl;
 
 system("pause");
}

6.对序列1、1、2、3、5、8、13。。。。  是Fab..数列

  2、3、5、13...是Fab..质数数列，因为他们与自己前面的Fab...数列都互质

给出k，返回第k小的Fab..质数

1 #include <iostream>

2 using namespace std;

3 

4 void GetPrimeNum(int k)

5 {

6 int a=1,b=2,c=2;

7 bool bcheck=true;

8 while(c<k)

9 {

10 for(int i=2;i<c;i++)

11 {

12 if(c%i==0&&c!=2)

13 bcheck=false;

14 }

15 if(bcheck)

16 {

17 cout<<c<<" ";

18 }

19 c=a+b;

20 a=b;

21 b=c;

22 bcheck=true;

23 }

24 cout<<endl;

25 }

26 int main(int argc, char *argv[])

27 {

28 int k;

29 cout<<"请输入一个数,获取比此数小的所有Fab..质数:"<<endl;

30 cin>>k;

31 cout<<"比"<<k<<"小的所有Fab..质数为:"<<endl;

32 GetPrimeNum(k);

33 return 0;

34 }

复制代码

7.101个硬币100真、1假，真假区别在于重量。请用无砝码天平称两次给出真币重还是假币

重的结论。

方法1： 
把硬币分成50，50，1。 
称50与50，如果平衡，则这两堆为真币，剩下的1为假币。再用这个假币和真币称一下得结论。 
若不平衡，则1为真币，接着判断假币在哪个堆里面。 
取轻的1堆，分成25，25，称重。若平衡则假币在另一堆里面，假币重。 
若不平衡，则假币在这一堆中，假币轻。 

方法2： 
把硬币分成33，33，34。 
称33与33，如果平衡，则这两堆为真币，假币在第三堆中。从66中取出34与第三堆进行称，第三堆所在的天平的那一端的轻重就是假币的轻重情况。 
若不平衡，则假币在这两堆中。取下轻的一堆，从34里面取出33替换，称量。如果平衡，代表取下的那一堆中有假币，假币是轻的。如果不平衡，代表取下的那一堆是真币，假币是重的。 

8.完成字符串拷贝可以使用 sprintf、strcpy 及 memcpy 函数，请问这些函数有什么区别

，你喜欢使用哪个，为什么？

答案：这些函数的区别在于 实现功能 以及 操作对象 不同。
1.strcpy 函数操作的对象是 字符串，完成 从 源字符串 到 目的字符串 的 拷贝 功能。
2.snprintf 函数操作的对象不限于字符串：虽然目的对象是字符串，但是源对象可以是字符串、也可以是任意基本类型的数据。这个函数主要用来实现（字符串或基本数据类型）向字符串的转换功能。如果源对象是字符串，并且指定 %s 格式符，也可实现字符串拷贝功能。
3.memcpy 函数顾名思义就是 内存拷贝，实现 将一个 内存块 的内容复制到另一个 内存块 这一功能。内存块由其首地址以及长度确定。程序中出现的实体对象，不论是什么类型，其最终表现就是在内存中占据一席之地（一个内存区间或块）。因此，memcpy 的操作对象不局限于某一类数据类型，或者说可 适用于任意数据类型，只要能给出对象的起始地址和内存长度信息、并且对象具有可操作性即可。鉴于 memcpy 函数等长拷贝的特点以及数据类型代表的物理意义，memcpy 函数通常限于同种类型数据或对象之间的拷贝，其中当然也包括字符串拷贝以及基本数据类型的拷贝。

对于字符串拷贝来说，用上述三个函数都可以实现，但是其实现的效率和使用的方便程度不同：

· strcpy 无疑是最合适的选择：效率高且调用方便。

· sprintf 要额外指定格式符并且进行格式转化，麻烦且效率不高。

· memcpy 虽然高效，但是需要额外提供拷贝的内存长度这一参数，易错且使用不便；并且如果长度指定过大的话（最优长度是源字符串长度 + 1），还会带来性能的下降。其实 strcpy 函数一般是在内部调用 memcpy 函数或者用汇编直接实现的，以达到高效的目的。因此，使用 memcpy 和 strcpy 拷贝字符串在性能上应该没有什么大的差别。

对于非字符串类型的数据的复制来说，strcpy 和 snprintf 一般就无能为力了，可是对 memcpy 却没有什么影响。但是，对于基本数据类型来说，尽管可以用 memcpy 进行拷贝，由于有赋值运算符可以方便且高效地进行同种或兼容类型的数据之间的拷贝，所以这种情况下 memcpy 几乎不被使用。memcpy 的长处是用来实现（通常是内部实现居多）对结构或者数组的拷贝，其目的是或者高效，或者使用方便，甚或两者兼有。

9.变量的声明和定义有什么区别？

10.请写出下面代码在 32 位平台上的运行结果，并说明 sizeof 的性质：

#include <stdio.h>

#include <stdlib.h>

int main(void)

{

        char a[30];

        char *b = (char *)malloc(20 * sizeof(char));        printf("%d\n", sizeof(a));

        printf("%d\n", sizeof(b));

        printf("%d\n", sizeof(a[3]));

        printf("%d\n", sizeof(b+3));

        printf("%d\n", sizeof(*(b+4)));

        return 0 ;

}