【C++】构造函数、析构函数、拷贝构造与运算符重载

文章目录

• 1.类的六个默认构造函数
• 2.构造函数
• • 2.1特性
  • • 2.1.1 函数名与类名相同
    • 2.1.2. 无返回值（不能写void）
    • 2.1.3. 对象实例化时编译器自动调用对应的构造函数
    • 2.1.4 构造函数可以重载
    • 2.1.5编译器生成默认的构造函数
    • 2.1.6编译器生成的默认构造有何用？
    • 2.1.7三种默认构造函数
    • 3.析构函数
    • • 3.1特性
      • • 3.1.1析构函数名是在类名前加上字符 ~
        • 3.1.2无参数无返回值类型（不能写void）
        • 3.1.3一个类只能有一个析构函数。
        • 3.1.4对象生命周期结束时，编译系统自动调用析构函数
        • 3.1.5编译器生成的默认析构函数
        • 4.拷贝构造
        • • 4.1特征
          • • 4.1.1拷贝构造函数是构造函数的一个重载形式
            • 4.1.2拷贝构造函数的参数
            • 4.1.3编译器生成默认的拷贝构造函数(浅拷贝)
            • 4.1.4拷贝构造函数典型调用场景：
            • 5.赋值运算符重载
            • • 5.1运算符重载
              • 5.2赋值运算符重载
              • • 5.2.1赋值运算符重载格式
                • 5.2.2返回值类型
                • 5.2.3检测是否自己给自己赋值
                • 5.2.4注意返回值
                • 5.2.5重载成类的成员函数
                • 5.2.6默认赋值运算符重载
                • 5.3前置++与后置++重载
                • 5.4运算符重载拓展
                • 6.const成员函数
                • 7.取地址及const取地址操作符重载

                  1.类的六个默认构造函数

                  如果一个类中什么成员都没有，简称为空类。

                  class test{};

                  空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

                  默认成员函数：用户没有显式实现，编译器自动生成的成员函数称为默认成员函数。

                  2.构造函数

                  class Data{public:void Init(int year = 1, int month = 1, int day = 1){this->_year = year;this->_month = month;this->_day = day;}void Print(){cout Data d1;d1.Init(2024, 5, 22);d1.Print();Data d2;d2.Init(2024, 5, 21);d2.Print();return 0;}public://构造Stack(size_t capacity = 3){this-_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}this-_capacity = capacity;this-_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}//析构~Stack(){ if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}private:DataType* _array;int _capacity;int _size;};int main(){Stack s;s.Push(1);s.Push(2);return 0;}public://构造函数Date(int year, int month, int day){this-_year = year;this-_month = month;this-_day = day;}//拷贝构造Date(const Date& d){this->_year = d._year;this->_month = d._month;this->_day = d._day;}private:int _year;int _month;int _day;};int main(){Date d1(2024,5,24);//拷贝构造//以下两种方式等价Date d2(d1);Date d3 = d1;return 0;}

                  4.1.2拷贝构造函数的参数

                  拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

                  为什么会引起无穷递归呢？

                  首先我们要知道，自定义类型传值传参要调用拷贝构造（可以看成一种规定）

                  下面的代码调试可以发现，当我们第一次按F11进入fun函数时，它是先进入到了Date类中的拷贝构造函数，第二次按F11才会进入fun函数。

                  如果这样，不写引用的话就会引发无穷的递归。

                  本来是只想调用拷贝构造，但是调用前要传参数，传递参数又要发生拷贝构造；那么还是要传递参数，此时就会形成没有尽头的递归，

                  4.1.3编译器生成默认的拷贝构造函数(浅拷贝)

                  若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

                  我们发现，对于所有成员确实都拷贝过去了，可是对于数组元素来说，它们两个数组的地址是相同的，也就是二者数组的同一块空间，这就有点不好了。

                  注意：

                  在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的；而自定义类型是调用其拷贝构造函数完成拷贝的。

                  4.1.4拷贝构造函数典型调用场景：

                  • 使用已存在对象创建新对象
                  • 函数参数类型为类类型对象
                  • 函数返回值类型为类类型对象

                    class Date { public:    Date(int year, int minute, int day)    {        cout         cout         cout     Date temp(d);    return temp; } int main() {    Date d1(2022,1,13);    Test(d1);    return 0; }if (d1._year