【Effective C++详细总结】第二章 构造/析构/赋值运算

简介: 【Effective C++详细总结】第二章 构造/析构/赋值运算

二、构造/析构/赋值运算

条款05:了解 C++ 默默编写并调用了哪些函数

在创建类时,如果自己不定义默认构造,拷贝构造(拷贝运算符),析构函数,那么编译器会自动生成这些函数。

//拷贝运算符:
classname& operator=(const classname& cn){......}

但是有些情况下编译器不会自动生成,拿下面这段代码举例:


67fbc902048e4b05814178098daa4581.png


可以发现由于 class 里出现了引用类型和 const 类型,故编译器就不会自动生成拷贝复制和移动赋值函数。

这是因为引用类型是引用其他地方的内容,如果调用拷贝赋值和移动赋值可能会顺带改变引用处的值。

而 const 类型本身就是不可改动的,所以不会生成拷贝赋值和移动赋值函数。

另外 mutex 本身不能被拷贝和移动,所以拷贝构造和移动构造函数也不会自动生成。

条款06:若不想使用编译器自动生成的函数,就应该明确拒绝

对于类中拷贝构造函数,我们应当阻止他们。但若是不声明,编译器也会自动生成拷贝构造函数。

在现代 c++ 中我们可以通过 delete 关键字对编译器自动生成的函数进行删除,如下图所示:



但在之前的 C++ 中并没有该关键字,所以可以用私有化的方式进行。

class person
{
private:
    person(const person&);
    person& operator=(const person&);
    //参数是不必要写的,毕竟这个函数不会被实现
public:
    ......
};

编译器自动生成的函数都是 public 函数,所以我们将 public 改为 private,就可以防止对象调用拷贝构造。

注:private 只有成员函数和友元函数可以调用。

同时也产生了一个问题,如何防止拷贝在成员函数或友元函数中被调用?

答案是建立一个父类,在父类中定义 private 拷贝函数,子类( person 等等)继承父类。因为子类不可以调用父类的 private 函数:

class uncopyable
{
private:
    uncopyable(const uncopyable&);
    uncopyable operator=(const uncopyable&);
};
class person{......};

条款07:为多态基类声明virtual析构函数

多态把父类当作一个接口,用以处理子类对象:利用父类指针,指向一个在堆区开辟的子类对象。

class person
{
public:
    person();
    ......
    ~person();
};
class teacher: public person{......};
person* p = new teacher(...); 
...
delete p;
//在堆区开辟的数据要手动删除

上述代码是有问题的。

我们知道,在普通类继承里,删除子类对象会先调用子类的析构,再调用父类的析构。但在多态里情况有所不同。我们删除的是父类指针,调用的只是父类的析构函数,子类析构不会被调用,也就是说,子类对象没有被删除,而指针却没了。这是局部销毁,会造成资源泄漏等错误。

幸运的是,我们可以通过虚函数来解决这个问题。

在多态里,虚函数可以让子类重写父类的函数,同时在虚函数表中生成一个指针,找到子类重写函数的地址,从而让我们可以通过父类访问子类重写的函数。

class person
{
public:
    person();
    ......
    virtual ~person();
};
class teacher: public person{......};
person* p = new teacher(...); 
...
delete p;
//删除 p 的时候调用 virtual ~person();
//virtual 找到子类析构函数的地址,导致子类也可以被删除

纯虚函数使得父类更像一个接口,这里不用多说。

注:多态里父类应该至少有一个虚函数(virtual 析构),若不用做多态,则类里不应该有虚函数。

条款08:别让异常逃离析构函数

释义:在析构函数内部处理异常

我们来看以下案例:

如果在 db.close() 处发生异常,则会导致不可预料的情况。

首先介绍一下异常处理的办法:

try
{...}
//try 内部写可能产生异常的语句,没有产生异常,则catch语句不执行,产生则一一匹配
//catch 用于捕获并处理异常,和 case 有异曲同工之妙
catch(...)
{
    1、可以使用 abort(); 函数终止程序
    2、可以吞下这个异常,在 catch 内部做一些处理
}

了解如何处理异常之后,我们就可以实现如条款所说,在析构函数内部处理异常

上面左边的方法是直接调用 abort 终止程序,右边则是直接吞下异常,只是记录个日志,后面再处理。

但是这两种方法都有个缺点就是用户无法参与操作,因此可以写成下面的方式:

用户可以自己实现一个 close 函数来进行关闭,如果关闭的顺利则 closed=true,反之关闭失败则会进行异常捕捉,在析构函数中帮助用户关闭。

条款09:绝不在构造和析构函数中使用虚函数

众所周知,在类的操作中,父类比子类先构造,而子类也比父类先析构(多态也是如此,多态先通过 virtual 找到子类析构,再析构父类),所以在构造父类的时候,子类对象还未进行初始化,在析构父类的时候,子类已经被销毁。来看下面这个例子:


f974df69902b43e3be29294b3fea60bd.png


此时,如果父类的构造和析构函数中有 virtual,则该函数无法找到子类的地址(或者说无视子类,因为子类被销毁/未被初始化),使程序发生不明确的行为。

可以发现上面我是想调用派生类的构造函数和析构函数,但是调用的却是基类的。如果想满足该要求,我们可以去掉虚函数,而是在基类接收一个参数来实现。


418cc4ba16794bd5b00de58a037369f4.png


条款10:令 operator= 返回一个 reference to *this

释义:让赋值运算符重载版本返回一个自身,以便实现链式编程。

class employee{
public:
  int m_salary;
  employee(int a)//有参构造,赋工资初值
  {
    this->m_salary = a;
  }
  employee& operator=(const employee& ep)
  {
    this->m_salary = ep.m_salary;
    return *this;
  }
    //返回其本身
};
  employee e1(5000);
  employee e2(50000);
  employee e3(123456);
  e1 = e2 = e3;
    //链式编程

条款11:在 operator= 中处理自我赋值

我们来看一段代码:

class person{...};
person p;
p = p;

这是自我赋值,这种操作看起来有点愚蠢,但是并不很难发生。

比如,一个对象可以有很多种别名,客户不经意间让这些别名相等;

或者如之前所说,父类的指针/引用指向子类的对象,也会造成一些自我赋值的问题。

自我赋值往往没有什么意义,还会有不安全性。

class student{...};
class teacher
{
    ...
private:
    student* s;
};
teacher& teacher::operator=(const teacher& teach)
{
    if(s != NULL)
    {
        delete s;
        s = NULL;
    }
    s = new student(*teach.s);
    return *this;//便于链式操作
}

上述代码是不安全的。如果 *this 和 teach 是同一个对象,那么客户在删除 *this 的时候,也把 teach 删除了,s 就会指向一个被删除的对象,这是不允许的。

我们提供三种方法以解决这个问题:

1、证同检测:

teacher& teacher::operator=(const teacher& teach)
{
    if (this == &teach)
        return *this;
    //证同检测
    if (s != NULL)
    {
        delete s;
        s = NULL;
    }
    s = new student(*teach.s);
    return *this;//便于链式操作
}

遗憾的是,证同检测可以保证自我赋值的安全性,但是不能保证“异常安全性”。即,如果 new student 抛出异常,则 s 就会指向一个被删除的对象,这是一个有害指针,我们无法删除,甚至无法安全读取它。

2、记住原指针:

teacher& teacher::operator=(const teacher& teach)
{
    student* stu = s;            //记住原指针
    if(s != NULL)
    {
        delete s;
        s = NULL;
    }
    s = new student(*teach.s);   //如果抛出异常,s 也可以找回原来地址
    delete stu;                  //删除指针
    return *this;//便于链式操作
}

3、copy and swap:

void swap(const teacher& teach)
{......}
teacher& teacher::operator=(const teacher& teach)
{
    teacher temp(teach);    //拷贝一个副本
    swap(temp);             //将副本和 *this 交换 
    return *this;//便于链式操作
}

交换操作不要考虑原本指针内容,可以保证赋值安全性,同时也能保证异常安全性。

条款12:复制对象时勿忘其每一个成分

释义:自定义拷贝函数时,要把类变量写全(子类拷贝不要遗漏父类的变量)。

父类变量通常存储在 private 里,子类不能访问父类 private 对象,所以应该调用父类的构造函数。

class animal
{
public:
    animal(const animal& an)
    {......}
    animal& opeartor=(const animal& an)
    {......}
......
private:
    string typename;
};
class cat: public animal
{
public:
    cat(const cat& c);
    cat& operator=(const cat& c);
private:
    string cat_type;
};
cat::cat(const cat& c)
    :cat_type(c.cat_type),
    //为了不遗漏父类变量,调用父类函数
    animal(c)
{}
cat::cat& operator=(const cat& c)
{
    //为了不遗漏父类变量,调用父类函数
    animal::operator=(c);
    this->cat_type = c.cat_type;
    return *this;
}

值得注意的是,上面代码 copy 函数和 “=” 运算符调用的都是和本身一样的函数。究其原因,copy 函数是创建一个新的对象,operator= 是对已经初始化的对象进行操作。

我们不能用 copy 调用 operator=,因为这相当于用构造函数初始化一个新对象(父类尚未构造好)。

同理,也不能用 operator= 调用 copy,这相当于构造一个已经存在的对象(父类已经存在了)。


目录
相关文章
|
1月前
|
C++
C++番外篇——对于继承中子类与父类对象同时定义其析构顺序的探究
C++番外篇——对于继承中子类与父类对象同时定义其析构顺序的探究
53 1
|
3月前
|
JavaScript Java C语言
面向对象编程(C++篇3)——析构
面向对象编程(C++篇3)——析构
30 2
|
3月前
|
JavaScript 前端开发 Java
面向对象编程(C++篇2)——构造
面向对象编程(C++篇2)——构造
31 0
|
5月前
|
C++ 容器
C++之deque容器(构造、赋值、大小、插入与删除、存取、排序)
C++之deque容器(构造、赋值、大小、插入与删除、存取、排序)
|
5月前
|
C++ 容器
C++字符串string容器(构造、赋值、拼接、查找、替换、比较、存取、插入、删除、子串)
C++字符串string容器(构造、赋值、拼接、查找、替换、比较、存取、插入、删除、子串)
|
4月前
|
编译器 C++
【C++】详解运算符重载,赋值运算符重载,++运算符重载
【C++】详解运算符重载,赋值运算符重载,++运算符重载
|
5月前
|
编译器 C++
【C++】类和对象③(类的默认成员函数:赋值运算符重载)
在C++中,运算符重载允许为用户定义的类型扩展运算符功能,但不能创建新运算符如`operator@`。重载的运算符必须至少有一个类类型参数,且不能改变内置类型运算符的含义。`.*::sizeof?`不可重载。赋值运算符`=`通常作为成员函数重载,确保封装性,如`Date`类的`operator==`。赋值运算符应返回引用并检查自我赋值。当未显式重载时,编译器提供默认实现,但这可能不足以处理资源管理。拷贝构造和赋值运算符在对象复制中有不同用途,需根据类需求定制实现。正确实现它们对避免数据错误和内存问题至关重要。接下来将探讨更多操作符重载和默认成员函数。
|
6天前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
29 4
|
7天前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
26 4
|
30天前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象(下)
【C++打怪之路Lv5】-- 类和对象(下)
27 4