笔试0227

cvte的笔试，更加侧重于底层，考的更多是计算机网络
都是选择题20+编程题2

MBR分区和GPT分区

• MBR最多支持2T，GPT理论是无限制的

• mbr最多支持四个主分区，gpt没有限制

  可以通过外部指针来访问类的私有成员

  批处理系统、分时系统和实时系统的区别

• 批处理，先处理一部分用户的作业，使共享CPU和系统资源，用户和作业没有交互性

• 分时系统一般采用时间片轮转的方式，使每一台计算机为多个终端用户服务，以最快的速度将结果显示给用户

• 实时系统是指系统能及时响应外部事件的请求，在规定的时间内完成对该事件的处理，并控制所有实时任务协调一致的运行。高精准计时系统，多级中断机制
  ，实时调用机制

结构体的大小（或者是类的大小）

函数是不占类空间，析构要产生额外的负担
结构体大小结果要为成员中最大字节的整数倍

const和constexpr的区别

constexpr：告诉编译器我可以是编译期间可知
const：侧重值不变

可重入函数

编写可重入函数时，若使用全局变量，则应通过关中断、信号量（即P、V操作）等手段对其加以保护。
说明：若对所使用的全局变量不加以保护，则此函数就不具有可重入性，即当多个进程调用此函数时，很有可能使有关全局变量变为不可知状态。

编码题

两个IP是否在一个子网下

思路如下：

• 分割字符串
• 直接用位与运算符

  #include<stdio.h>
  #include<string.h>
  #include<math.h>
  #include<vector>
  using namespace std;
   
  vector<char*> split(char str[]);  
  //将字符串192.168.1.1 转换为四个字符串 192 168 1 1存储在vector<char*>数组中 
  vector<int> trans_to_num(vector<char*> s);
  //将vector<char*>数组中的四个字符串 转换成四个整数 存储在vector<int>数组中  
  bool isSame(vector<int> ip1,vector<int> ip2,vector<int> mask); 
  //判断ip1和ip2是否在同一个子网，采用与运算，就不用转换2进制了
  void print(vector<int> ip1,vector<int> mask); 
  //输出第一个ip与mask相与的结果 
  int main()
  {
  	char ip1[50];
  	char ip2[50];
  	char mask[50];
  	scanf("%s %s %s",ip1,ip2,mask);
  	
  	vector<char*> ip1_str = split(ip1);
  	vector<char*> ip2_str = split(ip2);
  	vector<char*> mask_str = split(mask);
  	
  	vector<int> ip1_num = trans_to_num(ip1_str);
  	vector<int> ip2_num = trans_to_num(ip2_str);
  	vector<int> mask_num = trans_to_num(mask_str);
  	
  	if( isSame(ip1_num,ip2_num,mask_num) ){
  		printf("1 "); //在同一子网下 
  		print(ip1_num,mask_num);
  	}else{
  		printf("0 "); //不在同一子网下 
  		print(ip1_num,mask_num);
  	} 
  	
  	return 0;
  } 
  vector<char*> split(char str[])
  {
  	vector<char*> s;
  	char *p;
  	
  	p = strtok(str, ".");
  	s.push_back(p);
  	do{
  		p = strtok(NULL, ".");
  		if(p){
  			s.push_back(p);
  		}
  	}while(p);
  	
  	return s;
  }
  vector<int> trans_to_num(vector<char*> s)
  {
  	vector<int> nums;
  	for(int i=0; i<s.size(); i++){
  		int num = 0;
  		for(int j=strlen(s[i])-1,t=0; j>=0; j--,t++){
  			num += (s[i][j]-48)*pow(10,t);
  		}
  		nums.push_back(num);
  	}
  	return nums;
  }
  bool isSame(vector<int> ip1,vector<int> ip2,vector<int> mask) 
  { 
  	for(int i=0; i<ip1.size(); i++){
  		if((ip1[i]&mask[i])!=(ip2[i]&mask[i])){  //注意，&的优先级低于!=，所以要加括号 
  			return false;
  		}
  	}
  	return true;
  } 
  void print(vector<int> ip1,vector<int> mask)
  {
  	for(int i=0; i<ip1.size()-1; i++){
  		printf("%d.",ip1[i]&mask[i]);
  	}
  	printf("%d\n",ip1[3]&mask[3]);
  }

重写vector bit数组类型发DynamiBitset 数值bool 总长度size_t

这个我直接不会

template <typename Object>
class Vector
{
private:
    int theSize; //长度
    int theCapacity;//容量
    Object* objects; 
public:
    typedef Object* iterator;
    typedef const Object* const_iterator;
    static const int SPARE_CAPACITY = 16;
    //将构造函数声明为explicit ,是为了抑制由构造函数定义的隐式转换
    /*  构造函数的初始化列表.关于构造函数的初始化列表, 有两个要点.第一, 即使列表为空, 没有初始化式,构造函数也会先初始化每个成员再进入函数体, 这时初始化的规则与初始化变量相同,
        由此得知第二个要点:如果类的成员本身是一个没有默认构造函数的类类型, 或者成员是const、引用类型,这样的成员必须在构造函数初始化列表中进行初始化
    */
    explicit Vector(int initSize = 0) :theSize(initSize), theCapacity(initSize + SPARE_CAPACITY)
    { 
        objects = new Object[theCapacity];
    }
    Vector(const Vector& rhs) :objects(NULL)
    {
        operator=(rhs);
    }
    ~Vector()
    {
        delete[] objects;
    }

    const Vector& operator=(const Vector& rhs)
    {
        if (this != &rhs)
        {
            delete[] objects;
            theSize = rhs.theSize;
            theCapacity = rhs.theCapacity;
            objects = new Object[theCapacity];
            for (int k = 0; k < theSize; k++)
            {
                objects[k] = rhs.objects[k];
            }
        }
        return *this;
    }
    /* 由于成员函数的定常性是(即函数名后是否有const关键字)是签名的一部分,
     因此我们可以使用访问函数的operator[]版本返回const引用,而修改函数版本返回一般引用
    */
    Object& operator[](int index)
    {
        if (index < 0 || index >= theSize)
        {
            return objects[0];
        }
        cout << "--Object& operator[](int index)"<<endl;
        return objects[index];
    }
    const Object& operator[](int index)const
    {
        cout << "** const Object& operator[](int index)const" << endl;
        return objects[index];
    }
    //检测是否需要扩容
    void reserve()
    {
        reserve(theSize);
    }
    void reserve(int newSize)
    {
        if (theCapacity > newSize)
        {
            return;
        }
        int newCapacity = theCapacity * 2 + 1;
        Object* oldArr = objects;
        objects = new Object[newCapacity];
        for (int k = 0; k < theSize; k++)
        {
            objects[k] = oldArr[k];
        }
        theCapacity = newCapacity;
        delete[] oldArr;
    }
    int size()const
    {
        return theSize;
    }
    int capacity()const
    {
        return theCapacity;
    }
    bool empty()const
    {
        return theSize == 0;
    }
    void resize(int newSize)
    {
        reserve(newSize);
        theSize = newSize;
        theCapacity = newSize;
    }
    void push_back(const Object& obj)
    {
        reserve();      //检测容器大小
        objects[theSize++] = obj;
    }
    void pop_back()
    {
        theSize--;
    }
    const Object & back()const
    {
        return objects[theSize - 1];
    }
    Object* begin()
    {
        return &objects[0];
    }
    Object* end()
    {
        return &objects[theSize];
    }
    const Object* end()const
    {
        return&objects[theSize];
    }
    void toString()
    {
        cout << "Vecot长度:" << size() << ",容量：" << capacity() << endl;
        for (int i = 0; i < theSize; i++)
        {
            cout << "objects[" << i << "]:" << objects[i] << endl;
        }
    }
};