C++基础知识测试

2022-05-10 00:32:20 阅读：206 来源： 互联网

标签：obj struct int mField2 Object list 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

标签：obj,struct,int,mField2,Object,list,C++,基础知识,测试
来源： https://www.cnblogs.com/hsbook/p/16251831.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

C++基础知识测试