牛客练习错题总结

1、linux 创建文件的命令有（）

touch，cat，vi/vim，>

   
   
   
   

    
    
    
    touch命令 
创建空白文件或修改文件时间
cat主要有三大功能：
   
   
   
   
1.一次显示整个文件。
2.从键盘创建一个文件。
   只能创建新文件,不能编辑已有文件.

   
   
   
   

    
    
    
    3.将几个文件合并为一个文件
vi/vim可用来创建文件编辑文件并保存
> 是定向输出到文件，如果文件不存在，就创建文件；如果文件存在，就将其清空；
   
   
   
   
   
   
   
   

    
    
    
    2、32位机上，
    
    
    
    有三个类A B C定义如下, 请确定sizeof(A) sizeof(B) sizeof(C)的大小顺序.
    
    
    
    
struct A{
    A() {}
    ~A() {}
    int m1;
    int m2;
};
struct B:A{
    B() {}
    ~B() {}
    int m1;
    char m2;
    static char m3;
};
struct C{
    C() {}
    virtual~C() {}
    int m1;
    short m2;
};
则
    
    
    
    A
   
   
   
   
   
   
   
   

    
    
    
    
    
    
    
    

     
     
     
     答案解析：类的大小只与成员变量（非static数据成员变量）和虚函数指针有关，还要考虑到对齐. 
    
    
    
    
    
    
    
    那么类A的大小是8个字节；
    
    
    
    

    
    
    
    类B继承类A，在类A的8个字节基础上，再加上B自己的大小8字节，所以类B大小是16个字节；
    
    
    
    

    
    
    
    类C是4个字节+4个字节（考虑对齐）+4个字节（指向虚析构函数的指针）=12个字节
    
    
    
    

   
   
   
   
   
   
   
   

    
    
    
    3、下面这个代码输出的是()
    
    
    
    
#include        
#include 
using namespace std;
int main(void)
{
    vectorarray;
    array.push_back(100);
    array.push_back(300);
    array.push_back(300);
    array.push_back(300);
    array.push_back(300);
    array.push_back(500);
    vector::iterator itor;
    for(itor=array.begin();itor!=array.end();itor++)
    {
        if(*itor==300)
        {
            itor=array.erase(itor);
        }
    }
    for(itor=array.begin();itor!=array.end();itor++)
    {
            cout<<*itor<<"";
    }
  return 0;
}
    
    
    
    
100 300 300 500
    
    
    
    解析：vector::erase()：从指定容器删除指定位置的元素或某段范围内的元素
    
    
    
     
    
    
    
    

    
    
    
    vector::erase()方法有两种重载形式
    
    
    
     
    
    
    
    

    
    
    
    如下：
    
    
    
     
    
    
    
    

    
    
    
    iterator erase(   iterator _Where);
    
    
    
     
    
    
    
    

    
    
    
    iterator erase(   iterator _First,   iterator _Last);
    
    
    
     
    
    
    
    

    
    
    
    如果是删除指定位置的元素时：
    
    
    
     
    
    
    
    

    
    
    
    返回值是一个迭代器，指向删除元素下一个元素;
    
    
    
     
    
    
    
    

    
    
    
    

     
     
     
     如果是删除某范围内的元素时：返回值也表示一个迭代器，指向最后一个删除元素的下一个元素;
    
    
    
    
    
    
    
    

     
     
     
     

    
    
    
    
    
    
    
    

     
     
     
     在本题中，当 *itor==300成立时，删除第一个值为300的元素，同时itor指向下一个元素（即是第二个值为300的元素），
    
    
    
    
    
    
    
    

     
     
     
                                 在for(;;itor++)执行itor，itor指向第三个值为300的元素，进入下一个循环
    
    
    
    
    
    
    
    

     
     
     
              进入循环满足*itor==300，重复上面的过程，执行完循环，itor执行值为500的元素。
    
    
    
    
    
    
    
    

     
     
     
     所有整个过程中，只删除了2个值为300的元素。
    
    
    
    
1、
    
    
    
    对重载函数形象的描述中，正确的是（）
   
   
   
   
参数的类型可能不同，参数的顺序可能不同，函数的返回值类型可能不同，参数的个数可能不同
2、下述有关虚函数和纯虚函数说法错误的是？

同时含有纯虚拟函数的类称为抽象类，它可以被实例化，但是对象不可以调用纯虚函数（错误）
解析：virtual void func 加 “=0”，实现虚函数。
   
   
   
   

    
    
    
    抽象类中至少存在一个纯虚函数；存在纯虚函数的类一定是抽象类。存在纯虚函数是成为抽象类的充要条件。
   
   
   
   
   
   
   
   

    
    
    
    抽象类之所以不能被实例化，是因为它里面是抽象方法，实例化对象调用其里面的方法没有意义，我们需要做的就是覆写掉里面的抽象方法。 而这个抽象方法其实就是纯虚函数，通过派生类来override纯虚函数，定义N个方法。
   
   
   
   
   
   
   
   

    
    
    
    以下关于linux操作系统中硬链接和软链接的描述,正确的是?（b）

   
   
   
   
   
   
   
   

    
    
    
    a、
    
    
    
    硬链接和软链接指向的inode的编号是一样的
   
   
   
   
   
   
   
   

    
    
    
    b、
    
    
    
    可以建立一个空文件的软链接
   
   
   
   
   
   
   
   

    
    
    
    c、
    
    
    
    linux操作系统可以对目录进行硬链接
   
   
   
   
   
   
   
   

    
    
    
    d、
    
    
    
    硬链接指向inode节点
   
   
   
   
   
   
   
   

    
    
    
    解析：
    
    
    
    由于
    
    
    
    硬链接
    
    
    
    是有着相同 inode 号仅文件名不同的文件，因此硬链接存在以下几点特性：
    
    
    
    
    
    
    
    

     
     
     
     
文件有相同的 inode 及 data block；
     
     
     
     
只能对已存在的文件进行创建；
     
     
     
     
不能交叉文件系统进行硬链接的创建；
     
     
     
     
不能对目录进行创建，只可对文件创建；
     
     
     
     
删除一个硬链接文件并不影响其他有相同 inode 号的文件。
软链接与硬链接不同，若文件用户数据块中存放的内容是另一文件的路径名的指向，则该文件就是软连接。软链接就是一个普通文件，只是数据块内容有点特殊。软链接有着自己的 inode 号以及用户数据块。因此软链接的创建与使用没有类似硬链接的诸多限制：
      
      
      
      

       
       
       
       
软链接有自己的文件属性及权限等；
       
       
       
       
可对不存在的文件或目录创建软链接；
       
       
       
       
软链接可交叉文件系统；
       
       
       
       
软链接可对文件或目录创建；
       
       
       
       
创建软链接时，链接计数 i_nlink 不会增加；
       
       
       
       
删除软链接并不影响被指向的文件，但若被指向的原文件被删除，则相关软连接被称为死链接（即 dangling link，若被指向路径文件被重新创建，死链接可恢复为正常的软链接）。
       
       
       
       

        
        
        
        
 
         
软链接（符号链接） ln -s   source  target 
 
         
硬链接 （实体链接）ln       source  target
 
        
        
        
        
        
 
         参考：http://www.ibm.com/developerworks/cn/linux/l-cn-hardandsymb-links/ 
        
      
      
      
      
    
    
    
    
    
    
    
    

     
     
     
     1、关于KMP算法的说法，错误的是（d）
    
    
    
    
   
   
   
   

a、效率不一定比普通算法高

b、next值跟主串没有关系

c、计算next值时，模式串也可以看做主串

d、模式串next值从左到右增大

解析：kmp算法：

１后移， 直到字符串有一个字符，与搜索词的第一个字符相同为止．

２接着比较字符串和搜索词的下一个字符，直到字符串有一个字符，与搜索词对应的字符不相同为止

３根据部分匹配表，移动位数 = 已匹配的字符数 - 对应的部分匹配值

４ 逐位比较，直到搜索词的最后一位

2、字符串www.qq.com所有非空子串（两个子串如果内容相同则只算一个）个数是（ 50 ）

初步计算为(10+11)/2，除去重复的内容w(2次),ww（1次）,q(1次)，.（1次）共5次，则一共为55-5=50次

1、现在有以下语句：

1 2 3 4 5 6 7 8

struct _THUNDER{         int iVersion;         char cTag;         char cAdv;         int iUser;         char cEnd; }Thunder; int sz = sizeof(Thunder);

则执行后，变量sz的值将得到（16）

解析：结构体默认对齐方式为8，则iVersion取4字节对齐，CTag、CAdv和cEnd取2字节对齐，结构体大小为14,14不为4的整数倍，补空字节，增至16时符合所有条件，则sizeof（Thunder）为16。

参考：http://blog.chinaunix.net/uid-10995602-id-2918694.html

2、

在一个64位的操作系统中定义如下结构体：

1 2 3 4 5 6

struct st_task {      uint16_t id;      uint32_t value;      uint64_t timestamp; };

同时定义fool函数如下：

1 2 3 4 5 6 7

void fool() {      st_task task = {};      uint64_t a = 0x00010001;      memcpy (&task, &a,  sizeof (uint64_t));      printf ( "%11u,%11u,%11u" , task.id, task.value, task.timestamp); }

上述fool()程序的执行结果为（ 1，0，0）

解析： uint16_t id;//两个字节，16位

uint32_t value;//4个字节，32位

uint64_t timestamp;//8个字节，64位

0x00010001十六进制，共32位

id(16bits)+16bits+value(32bits)=64位，字节对齐需要

按照低位存储：

则id(16bits)+16bits会占据掉32bits的 0x00010001，id占据掉Ox0001，因此为1

3、 编译和执行如下c语言代码,系统将会输出什么?

1 2 3 4 5 6 7

#include int main() {      char c= '0' ;      printf ( "%d %d" , sizeof (c), sizeof ( char ));      return 0; } 解析：C语言: char a = 'a'; sizeof(char) = 1 sizeof(a) = 1 sizeof('a') = 4  C++语言: char a = 'a'; sizeof(char) = 1 sizeof(a) = 1 sizeof('a') = 1  字符型变量是1字节这个没错，奇怪就奇怪在C语言认为'a'是4字节，而C++语言认为'a'是1字节。        原因如下:     C99标准的规定，'a'叫做整型字符常量(integer    character constant)，被看成是int型，所以在32位机器上占4字节。   ISO C++标准规定，'a'叫做字符字面量(character literal)，被看成是char型，所以占1字节 4、 在32位机器上，下列代码中   sizeof(a)的值是（22） 解析：我来详细解释一下吧。 首先，#pragma pack(2)   强制设定为2字节对齐 i   4字节 u  一个为13，一个为4，默认为4字节对齐；      union占对齐后数据的最大字节大小，默认为13+3=4*4=16；      但是，该处强制为2字节对齐，实际为13+1=2*7=14字节 color   枚举类型的实例  4字节 4+14+4=22字节 1、假设在一个32位的little ender的机器上运行下面程序，输出的结果是（1，0，2） #include int  main(){    long  long  a = 1, b = 2, c = 3;     printf ( "%d %d %d\n" , a, b, c);     return  0; } 解析：1 printf()是一个库函数，C，C++中函数的参数是从右往左入栈的； 2 栈的生长方向是从高往低的 3 小端模式是低位存储在低字节 4 %d格式输出的是4个字节大小，而long long为8个字节 所以，a=1,b=0,c=2 2、 以下prim函数的功能是分解质因数。括号内的内容应该为？ 1 2 3 4 5 6 7 8 9 10 void prim( int m,  int n)   {       if (m >= n)       {           while (        ) n++;           (     );           prim(m, n);           cout << n << endl;       }   } 解析：第一处为m%n，代表取余。当余数是0的时候表示除尽，跳出while循环，即找出一个质因数。此时一个质因数即为n 然后 m/=n 即让m除去这个质因数，然后再进入求新m质因数的递归。 3、 下列程序段的输出结果是：（false   ）   void complicatedexpression_r(){ int x=20, y=30; boolean b; b=x>50&&y>60||x>50&&y<-60||x<-50&&y>60||x<-50&&y<-60; System.out.println(b); }