C++构造析构赋值运算函数应用详解

目录

• 了解C++默默编写哪些函数
• 不想使用编译器函数
• 为多态基类声明virtual析构函数
• 别让异常逃离析构函数
• 绝不在构造和析构过程中调用virtual函数
• 令operator=返回一个reference to *this
• 在operator=中处理自我赋值
• 复制对象时别忘了每个成分

了解C++默默编写哪些函数

当实现一个空类，c++会为你补上构造函数，拷贝构造函数，拷贝赋值运算符，析构函数

class Empty{};
//等于你写了
class{
public:
    Empty(){...};
    Empty(const Empty& rhs){...};
    ~Empty(){...};
    Empty& operator=(const Empty& rhs){...}
};

当这些函数被调用是，才会被编译器创建出来。如果你自己声明了一个构造函数，编译器将不会创建默认构造函数。

当然，编译器有时会拒绝生成operator=

class A{
public:
    NameObject{string& name};
private:
    string& nameValue;//为一个字符串引用
}
string newDog("peter");
string oldDog("fx")
A a(newDog);
A b(olddog);
a=b;//此处赋值就会导致a的nameValue绑定到不同对对象上面 而引用一旦绑定无法更改 是错误的

所以如果打算在一个含有引用成员的class中支持赋值操作，必须要自己定义operator=()

不想使用编译器函数

若不想使用编译器自动生成的函数，就该明确拒绝

如果一个类你想让它是独一无二，无法被拷贝的，则需要拒绝编译器生成的copy构造函数和copy赋值运算符。

方法一：将copy构造函数和copy赋值运算符函数声明为private并且故意不实现

class A{
public:
    ...
private:
    A(const A&);
    A& operator=(const A&);//只声明不实现
}

因为所有编译器生成的版本都是public。声明一个成员函数，阻止了编译器自己创建它，而声明为private，又可以阻止别人调用它。

客户试图拷贝A对象时，编译器会阻止，而当在member或friend函数之内调用时，连接器阻止.

方法二：写一个父类，将copy构造函数和copy赋值运算符函数声明为private并且故意不实现，再继承这个父类。

class A{
protected:
    A(){}
    ~A(){}
private:
    A(const A&);
    A& operator=(const A&)
}

为多态基类声明virtual析构函数

我的理解是：如果不这样做，在delete父类的指针的时候无法使用多态性质，只会删除掉父类的部分，而子类的部分会无法删除，造成局部销毁。

class A{
public:
    A();
    ~A();
};
class B:public A{};
//如果设计一个函数 返回一个基类的指针 可以使用多态 来自动判断是调用A还是B的析构来删除对象
A* base_pointer=getPointer();
delete base_pointer;
//当子类用一个指向父类的指针来执行删除，若父类的析构函数不是virtual，则无法调用子类的析构函数
//导致只删除 子类中父类的部分 剩下子类独有的部分

所以：无虚不基

base class的析构函数一定得是vritual，且可以推广到其他函数，若一个class里面没有一个virtual函数，那它不适合当一个base class。

class A{
public:
    A();
    virtual ~A();//应该这么搞
};
class B:public A{};
//如果设计一个函数 返回一个基类的指针 可以使用多态 来自动判断是调用A还是B的析构来删除对象
A* base_pointer=getPointer();
delete base_pointer;

但是，析构函数不能无端声明为virtual，因为声明为virtual需要虚表指针（vptr），vptr也是要占内存的，会增加对象的体积，减缓运行速度。

所以：当class至少含有一个virtual函数，才为它声明vritual虚构函数

当然，也可以将虚构函数声明为纯虚函数，使该class成为一个抽象基类，注意：必须为这个纯虚函数提供一份定义。因为析构函数是从派生类开始往基类调用，所以编译器会在A的派生类的析构函数中调用~A（）。

class A{
public:
    virtual~ A()=0;
}
A::~A(){}//必须为这个纯虚函数提供一份定义

别让异常逃离析构函数

C++不喜欢析构函数出现异常。

可以在发生异常时终止程序，也可以吞下发生的异常

A::~A()
{
    try{ a.close();}
    catch(...){
        ...
        //制作运转记录，记录下close的失败
        std::abort();//终止程序
    }
}
A::~A()
{
    try{ a.close();}
    catch(...){
        ...
       //记录下close的调用失败
    }
}

如果某个操作可能在失败时抛出异常，而又必须要处理这个异常，这个异常必须来自析构以外的函数。（这里其实不太理解，文中给的例子是用一个新的成员函数来直行关闭）

绝不在构造和析构过程中调用virtual函数

我的理解是：在构造和析构的过程中调用的virtual成员函数并没有多态性质（注意该虚函数不是指析构函数和构造函数是虚函数，而是除此之外的一个成员函数）

class A{
public:
    A();
    vritual void xxx() const =0;
};
A::A(){
    ...
    xxx();
}
class B:public A{
public:
    virtual xxx() const;
};
//当执行
B b;

派生类的base class成分会在派生类自身成分构造之前先构造，而A的构造函数调用了虚函数xxx，这时xxx是A的xxx，而不会多态调用B的xxx，即使目前是在创建B对象。

根本原因是：在派生类的基类构造期间，对象的类型是基类而不是派生类，只有当派生类自己的部分开始执行时，该对象才变成一个派生类。

该道理同样用于析构函数

改法为：将A类的xxx改为non-vritual，在派生类的构造函数传递必要信息给基类的构造函数

class A{
public:
    A();
    void xxx() const =0;
};
A::A(){
    ...
    xxx();
};
class B：public A{
public:
    B(parameters):A(createXXX(parameters))
    {...}
private:
    static string createXXX(parameters);
};

在构造期间，令派生类将必要的构造信息向上传递给基类的构造函数。

令operator=返回一个reference to *this

为了实现连锁赋值，赋值操作符必须返回一个reference指向操作符的左侧，这是为class实现赋值操作符时必须遵守的协议。

//连锁赋值
int x,y,z;
x=y=z=1;
class A{
public:
    A& operator=(const A& rhs)
    {
        return *this;
    }
}

在operator=中处理自我赋值

自我赋值发生在对象赋值给自己本身，例如*px=*py;

px和py都指向一个对象，则是一个自我赋值。

常发生在用引用赋值，指针赋值，多态等

可能会引发delete时将赋值和被赋值对象都删除了

避免方法：

1、证同测试

A &A operator=(const A& rhs){
    if(this==&rhs) return *this;//一样则什么也不做 直接返回
    ...
}

2、调整语序

class B{...};
class A{
private：
    B* pb;
}
A& A::operator=(const A& rhs){
    B* p=pb;//先记住原先的pb
    pb=new B(*rhs.pb);//令pb指向rhs.pb指向的一个副本，完成赋值
    delete p;//删除原来的pb
    return *this;
}

3、使用copy and swap，不大推荐

class A{
    ...
    void swap(A &rhs);
    ...
}
A& A::operator=(const A& rhs){
    A temp(rhs);//拷贝rhs的副本
    swap(temp);//交换
    return *this;
}

复制对象时别忘了每个成分

如果自己定义了拷贝构造函数，编译器将不会提醒你是否拷贝完所有成分，如果为class添加一个成员变量，则必须修改所有的copy函数和非标准形势的operator=

给派生类写copy函数的时候，也要复制它的基类的成分，那些成分往往是private，所以要让派生类调用相应的base class函数

B::B(const B &rhs):A(rhs),//调用基类的copy构造
...//对派生类部分初始化
{}
B::operator=(const B& rhs){
    A::operator=(rhs);//对基类部分赋值
    ...//对派生类部分赋值
    return *this;
}

编写copy函数时：

1、复制所有local成员变量

2、调用所有base classes内的适当copying函数

且不要尝试以某个copy函数实现另一个copy函数

到此这篇关于C++构造析构赋值运算函数应用详解的文章就介绍到这了,更多相关C++构造析构赋值运算内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！