备案控制台
开发者社区 开发与运维 文章 正文

【C++】类和对象 (中篇)（4）

2022-11-19 52
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【C++】类和对象 (中篇)（4）

4、特性分析 – 深浅拷贝

赋值重载函数的特性和拷贝构造函数非常类似 – 如果我们没有显式定义赋值重载，则编译器会自动生成一个赋值重载，且自动生成的函数对内置类型以字节为单位直接进行拷贝，对自定义类型会去调用其自身的赋值重载函数；

所以对于没有资源申请的类来说，我们不用自己去写赋值重载函数，直接使用默认生成的即可，因为这种类只需要进行浅拷贝 (值拷贝)，比如 Date 类：

2020062310470442.png注：拷贝构造函数完成的是初始化工作，在创建对象时自动调用；赋值重载完成的是已存在的对象之间的拷贝，需要手动调用；而上图中 Date d2 = d1 是在创建 d2 并对其进行初始化，所以调用的是拷贝构造函数；d3 才是调用赋值重载函数；

而对于有资源申请的类来说，我们必须自己手动实现赋值重载函数，来完成深拷贝工作；比如 Stack 类：

2020062310470442.png

20200623104134875.png

如图：这里的情况和 Stack 默认析构函数的情况很类似，但是比它要严重一些 – 自动生成的赋值重载函数进行浅拷贝，使得 st1._a 和 st2._a 指向同一块空间，而 st1 和 st2 对象销毁时编译器会自动调用析构函数，导致 st2._a 指向的空间被析构两次；同时，st1._a 原本指向的空间并没有被释放，所以还发生了内存泄漏；


所以，对于有资源申请的类我们都需要显式定义赋值重载函数；Stack 类的赋值重载函数如下：

//赋值重载
Stack& operator=(const Stack& st)
{
    free(_a);
    _a = (int*)malloc(sizeof(int) * st._capacity);
    if (_a == nullptr)
    {
        perror("malloc fail\n");
        exit(-1);
    }
    memcpy(_a, st._a, sizeof(int) * st._capacity);
    _top = st._top;
    _capacity = st._capacity;
    return *this;
}

2020062310470442.png

对于上面这段程序，可能有的同学会有这样一种疑问：我们可不可以直接对 st1._a 进行扩容呢？那样就不必释放后再出现申请空间了；答案是：直接扩容不是不行，但是不好，因为如果当 st1._capacity 大于 st2._capacity ，我们这时调用 realloc 就是缩容，而缩容需要重新开辟空间并拷贝原数据，效率太低；而如果面对这种情况我们不缩小空间直接拷贝数据的话又会造成空间的浪费；所以先释放原空间再开辟新空间是一种折中的办法；

现在我们为 Stack 类显示定义了赋值重载函数，那么我们再来运行一个新的测试用例：

2020062310470442.png

我们发现，当我们使用 st2 自己给自己赋值时，st2._a 中的数据变成了随机值；原因如下：operator= 函数首先会将 st2._a 指向的空间释放，然后再为其申请新空间，但是由于 st2 自己给自己赋值，所以使用 memcpy 拷贝的是新开辟的空间中的数据，即随机值；

2020062310470442.png

所以说，在赋值重载函数的函数格式规范中我们强调一定要检查自我赋值；Stack 类如下：

class Stack
{
public:
  Stack(int capacity = 4)  //构造
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (_a == nullptr)
    {
      perror("malloc fail\n");
      exit(-1);
    }
    _top = 0;
    _capacity = capacity;
  }
  ~Stack()  //析构
  {
    free(_a);
    _a = NULL;
    _top = _capacity = 0;
  }
  Stack(const Stack& st)  //拷贝构造
  {
    _a = (int*)malloc(sizeof(int) * st._capacity);
    if (_a == nullptr)
    {
      perror("malloc fail\n");
      exit(-1);
    }
    memcpy(_a, st._a, sizeof(int) * st._capacity);
    _top = st._top;
    _capacity = st._capacity;
  }
  Stack& operator=(const Stack& st)  //赋值重载
  {
    //自我赋值
    if (this == &st)
    {
      return *this;
    }
    free(_a);
    _a = (int*)malloc(sizeof(int) * st._capacity);
    if (_a == nullptr)
    {
      perror("malloc fail\n");
      exit(-1);
    }
    memcpy(_a, st._a, sizeof(int) * st._capacity);
    _top = st._top;
    _capacity = st._capacity;
    return *this;
  }
  void Push(int x)
  {
    _a[_top++] = x;
  }
private:
  int* _a;
  int _top;
  int _capacity;
};

另外，和拷贝构造一样，并不是说只要有资源申请我们就必须写赋值重载函数，比如 MyQueue 类，我们不写编译器调用默认生成的赋值重载函数，而默认生成的对于自定义类型会去调用它们自身的赋值重载函数；

2020062310470442.png

总结

自动生成的赋值重载函数对成员变量的处理规则和析构函数一样 – 对内置类型以字节方式按值拷贝，对自定义类型调用其自身的赋值重载函数；我们可以理解为：需要写析构函数的类就需要写赋值重载函数，不需要写析构函数的类就不需要写赋值重载函数；

七、取地址及 const 取地址重载

1、const 成员函数

我们将 const 修饰的 “成员函数” 称之为 const 成员函数，const 修饰类成员函数实际上修饰该成员函数隐含的 this 指针，表明在该成员函数中不能对 this 指向的类中的任何成员变量进行修改；

我们以Date类为例：

2020062310470442.png

我们看到，当我们定义了一个只读的Date对象 d2 时，我们再去调用 d2 的成员函数 Print 和 operator+ 时编译器会报错；原因在于类成员函数的第一个参数默认是 this 指针，而 this 指针的类型是 Date const*，而我们的第一个参数即 d2 的类型是 const Date*；将一个只读变量赋值给一个可读可写的变量时权限扩大，导致编译器报错；


注：成员函数默认第一个参数为 Date* const this，这里的 const 别放在 * 号后面，修饰的是 this 本身，表示 this 不能被修改，而 this 指向的内容即 d2 可以被修改；


另外，上面这个问题除了在定义对象时出现之外，在成员函数中也会出现，且十分频繁，特别是运算符重载 – 当运算符重载的两个参数都是类的对象时，如果我们不会改变类的内容，比如只比较大小，我们通常会将函数形参定义为 const Date& 类型，这时候问题就出现了：


我们不能在该成员函数中调用第二个对象的其他成员函数，因为在当前函数中该对象的类型为 const Date，当其调用其他成员函数时自身会作为第一个参数传递给成员函数的 this 指针，而 this 的类型为 Date* const，这时候又会发生权限扩大；

image.png

为了解决上面这个问题，C++ 允许我们定义 const 成员函数，即在函数最后面使用 const 修饰，该 const 只修饰函数的第一个参数，即使得 this 指针的类型变为 const Date const*；函数的其他参数不受影响；

2020062310470442.png

20200623104134875.png

将成员函数的 this 指针类型修饰为 const Date* const 后，不仅 const Date 的对象可以调用相应成员函数；正常的 Date 对象也可以调用，因为权限虽然不能扩大，但能缩小；

2020062310470442.png

所以，当我们在实现一个类时，如果我们不需要改变类的成员函数的第一个参数，即不改变 *this，那么我们就应该使用 const 来修饰 this 指针，以便类的 const 对象在其他 (成员) 函数中也可以调用本函数*；

以Date为例：

class Date
{
public:
  //构造
  Date();
  //获取每一个月的天数
  int GetMonthDay(int year, int month) const;
  //获取日期对应天数
  int GetDateDay() const;
  //打印
  void Print() const;
  //运算符重载
  //+=
  Date& operator+=(int day);
  //+
  Date operator+(int day) const;
  //-=
  Date& operator-=(int day);
  //-
  Date operator-(int day) const;
  //前置++
  Date& operator++();
  //后置++
  Date operator++(int);
  //前置--
  Date& operator--();
  //后置--
  Date operator--(int);
  //日期-日期
  int operator-(const Date& d) const;
  //>
  bool operator>(const Date& d) const;
  //==
  bool operator==(const Date& d) const;
  //>=
  bool operator>=(const Date& d) const;
  //<
  bool operator<(const Date& d) const;
  //<=
  bool operator<=(const Date& d) const;
  //!=
  bool operator!=(const Date& d) const;
private:
  int _year;
  int _month;
  int _day;
};

如上，不需要改变 *this 内容的 (即不改变指向对象的成员变量) 成员函数全部使用 const 修饰；

最后，我们来做几个思考题：

    const对象可以调用非const成员函数吗？-- 不可以，权限扩大；

    非const对象可以调用const成员函数吗？-- 可以，权限缩小；

    const成员函数内可以调用其它的非const成员函数吗？-- 不可以，权限扩大；

    非const成员函数内可以调用其它的const成员函数吗？-- 可以，权限缩小；

    2、取地址重载

    取地址重载函数是C++的默认六个成员函数之一，同时它也是运算符重载的一种，它的作用是返回对象的地址；

    Date* operator&()
{
    return this;
}

    2020062310470442.png

    3、const 取地址重载

    const 取地址重载也是C++的默认六个成员函数之一，它是取地址重载的重载函数，其作用是返回 const 对象的地址；

    const Date* operator&() const
{
    return this;
}

    2020062310470442.png

    如果我们没有显式定义取地址重载和 const 取地址重载函数，那么编译器会自动生成，因为这两个默认成员函数十分固定，所以大多数情况下我们直接使用编译器默认生成的即可，不必自己定义；

    在某些极少数的特殊情况下需要我们自己实现取地址重载与 const 取地址重载函数，比如不允许获取对象的地址，那么在函数内部我们直接返回 nullptr 即可：

    //取地址重载
Date* operator&()
{
    return nullptr;
}
//const 取地址重载
const Date* operator&() const
{
    return nullptr;
}

    2020062310470442.png

    八、总结

    C++的类里面存在六个默认成员函数 – 构造、析构、拷贝构造、赋值重载、取地址重载、const 取地址重载，其中前面四个函数非常重要，也非常复杂，需要我们根据具体情况判断是否需要显式定义，而最后两个函数通常不需要显示定义，使用编译器默认生成的即可；

    1、构造函数


      构造函数完成对象的初始化工作，由编译器在实例化对象时自动调用；

    默认构造函数是指不需要传递参数的构造函数，一共有三种 – 编译器自动生成的、显式定义且无参数的、显式定义且全缺省的；

    如果用户显式定义了构造函数，那么编译器会根据构造函数的内容进行初始化，如果用户没有显式定义，那么编译器会调用默生成的构造函数；

    默认生成的构造函数对内置类型不处理，对自定义类型会去调用自定义类型的默认构造；

    为了弥补构造函数对内置类型不处理的缺陷，C++11打了一个补丁 – 允许在成员变量声明的地方给缺省值；如果构造函数没有对该变量进行初始化，则该变量会被初始化为缺省值；

    构造函数还存在一个初始化列表，初始化列表的存在有着非常大的意义，具体内容我们在 [类和对象下篇] 讲解；

    2、析构函数

      析构函数完成对象中资源的清理工作，由编译器在销毁对象时自动调用；

      如果用户显式定义了析构函数，编译器会根据析构函数的内容进行析构；如果用户没有显示定义，编译器会调用默认生成的析构函数；

      默认生成的析构函数对内置类型不处理，对自定义类型会去调用自定义类型的析构函数；

      如果类中有资源的申请，比如动态开辟空间、打开文件，那么需要我们显式定义析构函数；


      3、拷贝构造


        拷贝构造函数是用一个已存在的对象去初始化另一个正在实例化的对象，由编译器在实例化对象时自动调用；

      拷贝构造的参数必须为引用类型，否则编译器报错 – 值传递会引发拷贝构造函数的无穷递归；

      如果用户显式定义了拷贝构造函数，编译器会根据拷贝构造函数的内容进行拷贝；如果用户没有显示定义，编译器会调用默认生成的拷贝构造函数；

      默认生成的拷贝构造函数对于内置类型完成值拷贝 (浅拷贝)，对于自定义类型会去调用自定义类型的拷贝构造函数；

      当类里面有空间的动态开辟时，直接进行值拷贝会让两个指针指向同一块动态内存，从而使得对象销毁时对同一块空间析构两次；所以这种情况下我们需要自己显式定义拷贝构造函数完成深拷贝；

      4、运算符重载


        运算符重载是C++为了增强代码的可读性而引入的语法，它只能对自定义类型使用，其函数名为 operator 关键字加相关运算符；

      由于运算符重载函数通常都要访问类的成员变量，所以我们一般将其定义为类的成员函数；同时，因为类的成员函数的一个参数为隐藏的 this 指针，所以其看起来会少一个参数；

      同一运算符的重载函数之间也可以构成函数重载，比如 operator++ 与 operator++(int)；

      5、赋值重载


        赋值重载函数是将一个已存在对象中的数据赋值给另一个已存在的对象，注意不是初始化，需要自己显示调用；它属于运算符重载的一种；

      如果用户显式定义了赋值重载函数，编译器会根据赋值重载函数的内容进行赋值；如果用户没有显示定义，编译器会调用默认生成的赋值重载函数；

      默认生成的赋值重载函数对于内置类型完成值拷贝 (浅拷贝)，对于自定义类型会去调用自定义类型的赋值重载函数；

      赋值重载函数和拷贝构造函数一样，也存在着深浅拷贝的问题，且其与拷贝构造函数不同的地方在于它还很有可能造成内存泄漏；所以当类中有空间的动态开辟时我们需要自己显式定义赋值重载函数来释放原空间以及完成深拷贝；

      为了提高函数效率与保护对象，通常使用引用作参数，并加以 const 修饰；同时为了满足连续赋值，通常使用引用作返回值，且一般返回左操作数，即 *this；

      赋值重载函数必须定义为类的成员函数，否则编译器默认生成的赋值重载会与类外自定义的赋值重载冲突；

      6、const 成员函数


        由于指针和引用传递参数时存在权限的扩大、缩小与平移的问题，所以 const 类型的对象不能调用成员函数，因为成员函数的 this 指针默认是非 const 的，二者之间传参存在权限扩大的问题；

      同时我们为了提高函数效率以及保护对象，一般都会将成员函数的第二个参数使用 const 修饰，这就导致了该对象在成员函数内也不能调用其他成员函数；

      为了解决这个问题，C++设计出了 const 成员函数 – 在函数最后面添加 const 修饰，该 const 只修饰 this 指针，不修饰函数的其他参数；

      所以如果我们在设计类时，只要成员函数不改变第一个对象，我们建议最后都使用 const 修饰；

      7、取地址重载与 const 取地址重载

      • 取地址重载与 const 取地址重载是获取一个对象/一个只读对象的地址，需要自己显式调用；它们属于运算符重载，同时它们二者之间还构成函数重载；
      • 大多数情况下我们都不会去显示实现这两个函数，使用编译器默认生成的即可；只有极少数情况需要我们自己定义，比如防止用户获取到一个对象的地址；
      文章标签：
      C++
      测试技术
      编译器
      关键词：
      C++类
      C++类对象
      C++对象
      野猪佩奇`
      目录
      相关文章
      დ旧言~
      |
      3天前
      |
      设计模式 安全 编译器
      【C++11】特殊类设计
      【C++11】特殊类设计
      დ旧言~
      22 10
      芯动大师
      |
      8天前
      |
      C++
      C++友元函数和友元类的使用
      C++中的友元（friend）是一种机制，允许类或函数访问其他类的私有成员，以实现数据共享或特殊功能。友元分为两类：类友元和函数友元。类友元允许一个类访问另一个类的私有数据，而函数友元是非成员函数，可以直接访问类的私有成员。虽然提供了便利，但友元破坏了封装性，应谨慎使用。
      芯动大师
      39 9
      小余大牛成长记
      |
      3天前
      |
      存储 编译器 C语言
      【C++基础 】类和对象（上）
      【C++基础 】类和对象（上）
      小余大牛成长记
      7 1
      ForcibleBugMaker
      |
      12天前
      |
      编译器 C++
      【C++】string类的使用④（字符串操作String operations ）
      这篇博客探讨了C++ STL中`std::string`的几个关键操作，如`c_str()`和`data()`，它们分别返回指向字符串的const char*指针，前者保证以&#39;\0&#39;结尾，后者不保证。`get_allocator()`返回内存分配器，通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组，不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量，表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。
      ForcibleBugMaker
      19 1
      ForcibleBugMaker
      |
      12天前
      |
      存储 C++
      【C++】string类的使用③（非成员函数重载Non-member function overloads）
      这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容，包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容，成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接，关系运算符（如`==`, `&lt;`等）用于比较字符串，以及`swap`非成员函数。此外，还介绍了`getline`函数，用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用，并给出了多个示例代码。
      ForcibleBugMaker
      11 1
      ForcibleBugMaker
      |
      12天前
      |
      C++
      【C++】string类的使用④（常量成员Member constants）
      C++ `std::string` 的 `find_first_of`, `find_last_of`, `find_first_not_of`, `find_last_not_of` 函数分别用于从不同方向查找目标字符或子串。它们都返回匹配位置，未找到则返回 `npos`。`substr` 用于提取子字符串，`compare` 则提供更灵活的字符串比较。`npos` 是一个表示最大值的常量，用于标记未找到匹配的情况。示例代码展示了这些函数的实际应用，如替换元音、分割路径、查找非字母字符等。
      ForcibleBugMaker
      13 0
      ForcibleBugMaker
      |
      12天前
      |
      C++
      C++】string类的使用③（修改器Modifiers）
      这篇博客探讨了C++ STL中`string`类的修改器和非成员函数重载。文章介绍了`operator+=`用于在字符串末尾追加内容，并展示了不同重载形式。`append`函数提供了更多追加选项，包括子串、字符数组、单个字符等。`push_back`和`pop_back`分别用于在末尾添加和移除一个字符。`assign`用于替换字符串内容，而`insert`允许在任意位置插入字符串或字符。最后，`erase`函数用于删除字符串中的部分内容。每个函数都配以代码示例和说明。
      ForcibleBugMaker
      11 0
      ForcibleBugMaker
      |
      12天前
      |
      安全 编译器 C++
      【C++】string类的使用②（元素获取Element access）
      ```markdown 探索C++ `string`方法：`clear()`保持容量不变使字符串变空；`empty()`检查长度是否为0；C++11的`shrink_to_fit()`尝试减少容量。`operator[]`和`at()`安全访问元素，越界时`at()`抛异常。`back()`和`front()`分别访问首尾元素。了解这些，轻松操作字符串！💡 ```
      ForcibleBugMaker
      14 0
      ForcibleBugMaker
      |
      12天前
      |
      存储 编译器 Linux
      【C++】string类的使用②（容量接口Capacity ）
      这篇博客探讨了C++ STL中string的容量接口和元素访问方法。`size()`和`length()`函数等价，返回字符串的长度；`capacity()`提供已分配的字节数，可能大于长度；`max_size()`给出理论最大长度；`reserve()`预分配空间，不改变内容；`resize()`改变字符串长度，可指定填充字符。这些接口用于优化内存管理和适应字符串操作需求。
      ForcibleBugMaker
      10 0
      ForcibleBugMaker
      |
      12天前
      |
      C++ 容器
      【C++】string类的使用①（迭代器接口begin，end，rbegin和rend）
      迭代器接口是获取容器元素指针的成员函数。`begin()`返回首元素的正向迭代器，`end()`返回末元素之后的位置。`rbegin()`和`rend()`提供反向迭代器，分别指向尾元素和首元素之前。C++11增加了const版本以供只读访问。示例代码展示了如何使用这些迭代器遍历字符串。
      ForcibleBugMaker
      13 0