专项训练知识点与错题整理-nowcoder-c++

1- 来自：http://www.cskaoyan.com/thread-595813-1-1.html

1.拷贝构造函数

转自：https://www.cnblogs.com/alantu2018/p/8459250.html

即自定义的特殊的构造函数，要求有两点：

①必须和类名同名。

②参数是本类的引用。

那么问题来了，这个函数在什么时候被调用呢？有三种情况：

①当函数参数为类的对象时

②当函数返回类型为类的对象时（它会首先赋值给一个临时变量然后返回，同时销毁自己。下面给个例子，感觉很受启发。）

彡当一个对象需要另一个对象进行初始化时

//（在进行类直接赋值的时候，这条是我自己总结的。）

#include<iostream>
using namespace std;
class CExample
{
private:
    int a;
public:
    //构造函数
    CExample(int b)
    {
     a=b;
        printf("constructor is called\n");
    }
    //拷贝构造函数
    CExample(const CExample & c)
    {
     a=c.a;
        printf("copy constructor is called\n");
    }
    //析构函数
    ~CExample()
    {
     cout<<"destructor is called\n";
    }
    void Show()
    {
     cout<<a<<endl;
    }
};
CExample g_fun()
{
    CExample temp();
    return temp;
}
int main()
{

    g_fun();
    return ;
}

return object

 重点来了：拷贝分为深拷贝和浅拷贝！

1）默认是浅拷贝的，给出了一个例子，并不会对 静态数据成员进行操作；一般情况下只是进行简单的赋值，但是如果有动态申请空间的时候，就会出现问题：

给出了一个例子；

#include<iostream>
#include<assert.h>
using namespace std;
class Rect
{
public:
    Rect()
    {
     p=new int();
    }

    ~Rect()
    {
     assert(p!=NULL);
        delete p;
    }
private:
    int width;
    int height;
    int *p;
};
int main()
{
    Rect rect1;
    Rect rect2(rect1);
    return ;
}

Dynamic memory

//此时两个p指向同一块内存，那么析构函数就会对一个内存空间释放两次！导致出现错误。

2）实现深拷贝函数

#include<iostream>
#include<assert.h>
using namespace std;
class Rect
{
public:
    Rect()
    {
     p=new int();
    }

    Rect(const Rect& r)//手动实现拷贝构造函数
    {
     width=r.width;
        height=r.height;
     p=new int();
        *p=*(r.p);//这个是使其存储的内容相同！
    }

    ~Rect()
    {
     assert(p!=NULL);
        delete p;
    }
private:
    int width;
    int height;
    int *p;
};
int main()
{
    Rect rect1;
    Rect rect2(rect1);
    return ;
}

Deep Copy

//手动实现拷贝构造函数

3）防止默认拷贝发生

防止出现默认拷贝了值，对于动态申请出错的现象，定义一个私有的拷贝构造函数但不必实现，即声明即可。

#include<iostream>
using namespace std;
//防止按值传递
class CExample
{
private:
    int a;

public:
    //构造函数
    CExample(int b)
    {
        a = b;
        cout<<"creat: "<<a<<endl;
    }

private:
    //拷贝构造函数，只是声明
    CExample(const CExample& C);

public:
    ~CExample()
    {
        cout<< "delete: "<<a<<endl;
    }

    void Show ()
    {
        cout<<a<<endl;
    }
};

//????
void g_Fun(CExample C)
{
    cout<<"test"<<endl;
}

int main()
{
    CExample test();
    g_Fun(test);   //按值传递将出错

    return ;
}

Fobbid Default

总结：在有指针的时候不能使用浅拷贝！会导致析构函数析构两次从而发生错误！

二者主要区别就是在拷贝时，会在堆内存中申请额外空间来存储数据。

细节也是重点：

1.为什么拷贝构造函数是引用传递而不是值传递?

//这个没看答案之前我还真是想不出来，但是你想想调用拷贝构造函数的情况包括作为函数参数传递，那么如果是这样的话，就会引起递归调用拷贝构造函数，造成无限递归！

2.拷贝构造函数可以操作private类型的变量吗？

拷贝构造函数就是一个特殊的构造函数，操作的还是自己的成员变量，所以不受private的限制。（其实这个还不太明白。）

常见面试题，重点啊：

1.构造函数能否重载，析构函数能否重载，为什么？

构造函数可以重载（可以创建多个带参数的），析构函数不可以（只能有一个，不能带参数，无返回值，无类型）。

2.析构函数为什么一般情况下要声明为虚函数？

虚函数是实现多态的基础，当我们通过基类的指针是析构子类对象时候，如果不定义成虚函数，那只调用基类的析构函数，子类的析构函数将不会被调用。如果定义为虚函数，则子类父类的析构函数都会被调用。

2.  ::在C++种是什么意思？

表示“域操作符”，比如在类A里给出了成员函数声明void f()，在类外进行定义的时候就要写成void A::f()。即表示是类A的成员函数。

3.运算符重载

有什么要求限制呢？

1）不能改变原有操作符的操作数目；（双目与单目）

2）不能改变原有操作符的结合顺序；

3）不创建新的运算符。

可以运用成员函数/友元函数进行重载：

返回类型 operator 运算符（参数表）{//实现}

①一般来说参数表中数目要和运算符数目相同，但是如果是成员函数那么就减少一个参数。

②参数表中至少有一个是类的成员，而不能都是int,int，int是内置类型。

彡有显式调用和隐式调用：a+b/a.operator+(b)；

//对于双目运算符而言，只有一个形参即可，第一个是通过this指针传递的。

4.c++种虚函数和纯虚函数？

虚函数是为了实现多态，被virtual关键字修饰，虚函数必须实现；

纯虚函数是针对那些不能生成对象的类，即抽象类。

那么重点来了，在什么情况下使用纯虚函数？

）在基类种抽象出一个方法，这个基类只能被继承，不能被实例化（避免它去实例化），并且方法要在派生类中实现。

class CShape
{
public:
    virtual void Show()=;
};

5.C和C++有什么区别呢?

1）C是面向过程的语言，C++是面向对象的语言，C++可以说是C的超集，包含C的特性

2）C中动态内存管理是malloc/free，C++中是new/delete

3）C中没有类，只有strcut，c++中有class，只是它的默认属性是private的，这是和C的区别

4）C中不能进行函数重载，因为C++中函数进行名字修饰之后不仅包括函数名，而且包括每个参数的类型；但是C中只包括函数名

5）C中没有引用

5.1 malloc和new的区别

malloc:是在堆中分配内存，并且是个函数，需要指明分配空间的大小，分配成功时返回void*，需要进行强制类型转换；

new：是在自由存储区，既可以是堆，也可以是静态存储区；分配成功时返回指针，不成功时抛出异常。

5.2 指针和引用的区别

1）指针有自己的一块存储空间，而引用只是一个别名

2）指针可以指向别的地址空间，但是引用只能是一个对象的引用，并且初始化时指针可以指向空，但是引用必须被初始化为一个已有对象

3）还有在作为函数参数传递时的一些区别！

5.3 static关键字和const关键字

static:

①如果是全局的那么存储区域就被存到全局静态区，局部的话就存到静态数据区；

②如果它是之前函数内的局部变量，那么生命周期就变成了从整个程序开始到结束；

彡：在修饰类的成员变量和函数时，它们就会变成是类的，而不是对象的，属于所有的实例类。

const:

①全局：就像#define，并且不能被修改

②局部变量，表示值不能被修改

彡：修饰指针：有指针常量和常量指针；（前者是指针不能只想别的地址空间，后者是它指向的内容不能被修改，）

④：在作为函数参数传递的时候，const不可以被传为非const的，而反过来可以。

6.静态全局变量和静态局部变量的区别

静态局部变量：在函数内定义，在函数调用后就一直存在，生命周期是整个程序，但是访问范围仍然是在函数内，不是全局的。

当要多次调用一个函数并且需要保存某些变量的值得时候可以使用！//这个着实没有想到。

静态变量是存储在程序数据段，也就是静态内存分配，存放已经初始化的。