C++基础知识测试

1:构造函数有几种:

a:默认构造函数 b:复制(拷贝)构造函数 c:初始化构造函数 d:转换构造函数 e:移动构造函数 

 2:赋值函数有几种

a:拷贝赋值 b:操作符“=”重载为赋值函数 

 3:纯虚函数不能再哪些函数内使用

a:从基类构造函数直接调用 b:从基类析构函数直接调用 c:从基类构造函数间接调用 d:从基类析构函数间接调用 e:通过悬空指针调用 

 

4:修正下面代码

stuct Object{     Object(int a,int b);    }; 

 

 

5:修正下面代码

 参考连接:https://blog.csdn.net/guotianqing/article/details/103298909

struct Object{    ~Object()      {         this->func();         mObj->func();     }       virtual void func() = 0;       Object* mObj; }    

改为:
struct Object{
    ~Object()
     {
       //this->func(); 不能在基类构造函数和析构函数中直接或间接调用虚函数
       //mObj->func(); 不能用悬空指针调用虚函数
     }
     virtual void func() = 0;
     Object* mObj;
  }

6:test 方法将调用哪个func方法

class Object{    void func() const;  //方法1    void func();  //方法2    void test()    {      this->func();    }    } 

 答案:方法2

7:修正下面方法

struct Object{     int getValue()      {           return mValue;      } } 修改: struct Object{     int getValue() const  //获取函数带const,方便调用人员知道内部数据没有被修改      {            return mValue;      }        int mValue; } 

 8:修正下面代码

struct Object1 {     void setValue(Object2& val)     {      mValue = val;     } }  改为: 

 9:修正下面代码:

struct Base{     virtual void func1(int v1,double v2,const String& v3)=0; }  struct Object:Base {    void func1(int v1,double v2, const String v3); }  将继承类改为 struct Object:Base {    void func1(int v1,double v2, const String& v3);  //参数调用类型和基类虚函数一致 } 

 

10:完成Object::Object()函数

struct Base{		     Base(int);		 };		 struct Object: Base{		     struct MyObject{		         MyObject(int);		     };		     Object(){		         		     }		     const int mField1;		     double    mField2;		     MyObject  mField3;		 };		 

 修改:

struct Base {     Base()  //添加默认构造函数,不然编译不过     {     }     Base(int n):a(n)     {     }     int a; }; struct Object : Base {     struct MyObject {         MyObject()   //添加默认构造函数,不然编译不过         {         }         MyObject(int n):a1(n)         {         }         int a1;     };     Object():mField1(0)  //常数必须在初始化列表进行初始化     {         mField2 = 0;         mField3 = 0;  //调用转换构造函数     }     const int mField1;     double    mField2;     MyObject  mField3; }; 

 11:RAII全名

答:Resource Acquisition is Initialization   (资源获取即初始化)

 

 12:完成所有函数

struct Object{			     Object(){					     }			     Object(Object&& obj){					     }			     Object(const Object& obj){//使用深拷贝						     }			     Object& operator=(Object&& obj){					     }			     Object& operator=(const Object& obj){//使用深拷贝						     }			     ~Object(){					      }			      int  mField1;			      int* mField2;			 };			 

 答:

struct Object {     Object() {      }     Object(Object&& obj) {         obj.mField2 = nullptr;         this->mField1 = obj.mField1;     }     Object(const Object& obj):mField1(obj.mField1),mField2(obj.mField2) //使用深拷贝     {			     }     Object& operator=(Object&& obj) {     }     Object& operator=(const Object& obj) {//使用深拷贝			          if (this != &obj)  //避免自赋值         {             if (mField2 != nullptr) //避免内存泄露             {                 delete mField2;                 mField2 = nullptr;             }             mField2 = new int(*obj.mField2);         }         return *this;     }     ~Object() {         delete mField2;         mField2 = nullptr;     }     int  mField1;     int* mField2; }; 

13:以下代码将发生几次对象构造

vector<Object> list;		 list.push_back(1);//   2次	 list.emplace_back(1);//   1次		 

 14:分别指出下面代码复杂度

std::vector<int>             list1;			 std::list<int>                 list2;			 std::map<int, int>         list3;			 std::set<int>                list4;			 std::unordered_map<int, int> list5;			 std::unordered_set<int>        list6;			 list1.erase(list1.begin());//1	O(N)		 list2.erase(list2.begin());//2  O(1)			 list3.erase(list3.begin());//3	O(log^N)		 list4.erase(list4.begin());//4	O(log^N)	 list5.erase(list5.begin());//5			 list6.erase(list6.begin());//6			 

 15:以下代码的执行结果(假设insert过程不扩容)

ListType list;			 list.insert(list.begin(), 2);			 list.insert(list.begin(), 7);			 list.insert(list.begin(), 2);			 list.insert(list.begin(), 1);			 for(auto val : list){			     print(val);			 }			 当ListType分别是以下类型时的打印结果			 std::vector<int>        : 	1,2,7,2	 std::list<int>          :	1,2,7,2		 std::set<int>           :	1,2,7		 std::unordered_set<int> :	2,7,1