C++ 类默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员
函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

构造函数

class Date {};

class Date
{
public:
    void Init(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    //我们可以在类里面创建一个成员函数，通过调用这个成员函数对类进行初始化
    d1.Init(2022, 9, 25);
    d1.Print();
    
    
    return 0;
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置
信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢 。

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证
每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。

其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date
{
public:
//    void Init(int year,int month,int day)
//    {
//        _year = year;
//        _month = month;
//        _day = day;
//    }
    // 1.无参构造函数
    Date()
    {}
    // 2.带参构造函数
    Date(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    //在创建类的同时初始化
    Date d1;//调用无参构造函数
    Date d2(2022,9,25);//调用带参构造函数
    
    d1.Print();
    d2.Print();
    return 0;
}

 d1在调用无参构造函数时，并没有赋值，所以打印出来的是随机值，d2在调用带参构造函数时赋值了，所以打印出来的是赋的值。

如果我们不写构造函数，会是什么样的呢？

class Time
{
public:
    Time()
    {
        _hour = 16;
        _minute = 23;
        _second = 44;
        cout << "Time()" <<_hour <<":"<<_minute<<":"<<_second <<endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
public:
    void Print()
    {
        cout <<"Date()"<< _year << "-" << _month << "-" << _day << endl;
    }
private:
    // 基本类型(内置类型)
    int _year;
    int _month;
    int _day;
    //自定义类型
    Time _t;
    
};

int main()
{
    Date d1;
    d1.Print();
    return 0;
}

关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用？d1对象调用了编译器生成的默
认构造函数，但是d1对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用？？

解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认构造
函数

class Date
{
private:
    // 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d;
    return 0;
}

C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。

class Date
{
public:
    //无参构造函数
    Date()
    {
        _year = 2022;
        _month = 9;
        _day = 25;
    }
    //全缺省构造函数
    Date(int year = 2022,int month = 9,int day = 25)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout <<"Date()"<< _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
    //自定义类型
    Time _t;
    
};
//由于我们有一个无参构造函数，和一个全缺省的构造函数，这时我们编译会出错
//编译器不知道要选择那个构造函数了，全缺省和无参在编译器看来是一样的
int main()
{
    Date d1;
    d1.Print();
    return 0;
}

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数。

析构函数

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

特性

析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:
    //构造函数
    Stack(DataType capacity = 4)
    {
        _array = (DataType*)malloc(sizeof(DataType)*capacity);
        if(nullptr == _array)
        {
            perror("malloc fail");
            exit(-1);
        }
        _capacity = capacity;
        _size = 0;
    }
    //析构函数
    ~Stack()
    {
        if(_array != nullptr)
        {
            free(_array);
            _array = nullptr;
            _capacity = _size = 0;
        }
    }
private:
    DataType* _array;
    int _size;
    int _capacity;
};

int main()
{
    Stack st;
    
    return 0;
}
// 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如
Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类（空间申请之类的），

拷贝构造函数

在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

特征

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式

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

class Date
{
public:
    Date(int year = 2022,int month = 9 ,int day = 25)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //Date(const Date d)//错误写法，会无限递归
    Date(const Date& d)//正确拷贝写法，需要加引用
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    void Print()
    {
        cout<<_year <<"-" << _month<<"-"<<_day<<endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    d1.Print();
    Date d2(d1);
    d2.Print();
    return 0;
}

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

class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
    }
    Time(const Time& t)
    {
        _hour = t._hour;
        _minute = t._minute;
        _second = t._second;
        cout << "Time::Time(const Time&)" << endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
private:
    // 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d1;
    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构
    造函数
    Date d2(d1);
    return 0;
}

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

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试?

typedef int DataType;
class Stack
{
public:
    //构造函数
    Stack(DataType capacity = 4)
    {
        _array = (DataType*)malloc(sizeof(DataType)*capacity);
        if(nullptr == _array)
        {
            perror("malloc fail");
            exit(-1);
        }
        _capacity = capacity;
        _size = 0;
    }
    //析构函数
    ~Stack()
    {
        if(_array != nullptr)
        {
            free(_array);
            _array = nullptr;
            _capacity = _size = 0;
        }
    }

    void Print()
    {
        cout<<"内存地址:"<< &_array <<endl;
    }
private:
    DataType* _array;
    int _size;
    int _capacity;
};

int main()
{
    Stack st1;
    st1.Print();
    Stack st2(st1);
    st1.Print();
    
    return 0;
}

st1创建用默认构造函数创建了四个元素的空间，然后里面存了1，2
st2对象使用st1拷贝构造，而我们没有写拷贝函数，则编译器会默认给stack类生成一个拷贝函数
默认拷贝构造函数是按照值拷贝，即将st1中内容原封不动的拷贝到st2中，所以st1和st2是指向同一块空间的，当程序退出时，st2会先销毁，st2已经将st1和st2指向空间释放了，而st1不知道，他又执行了一遍释放空间，一块空间两次释放，肯定会造成运行崩溃的

 注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝

    //深拷贝函数
    Stack(const Stack& d)
    {
        _array =(int*) malloc(sizeof(int)*d._capacity);
        if(nullptr == _array)
        {
            perror("malloc fial");
            exit(-1);
        }
        _capacity = d._capacity;
        _Top = d._Top;
    }

用我们自己写的拷贝函数，则st1和st2不再是指向同一块空间的。 

5. 拷贝构造函数典型调用场景：
。使用已存在对象创建新对象
。函数参数类型为类类型对象
。函数返回值类型为类类型对象

赋值运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其
返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

注意：
1,不能通过连接其他符号来创建新的操作符：比如operator@
2,重载操作符必须有一个类类型参数
3,用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
4,作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this
5, (“?:” “.” “::” “sizeof” “.*” )  注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

operator== 重载

class Date
{
public:
    Date(int year = 2022,int month = 9 ,int day = 25)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    // ==运算符重载
    // bool operator==(Date* this, const Date& d2) 这是我们把隐藏的this加上的函数形参原型
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d)
    {
      return _year == d._year &&_month == d._month &&_day == d._day;
    }
    //Date(const Date d)//错误写法，会无限递归
    Date(const Date& d)//正确浅拷贝写法
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    void Print()
    {
        cout<<_year <<"-" << _month<<"-"<<_day<<endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    d1.Print();
    Date d2;
    d2.Print();
    cout<<(d1 == d2)<<endl;
    return 0;
}

operator+= 重载

class Date
{
public:
    // 获取某年某月的天数
    int GetMonthDay(int year, int month)
    {
        static int days[]= {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31};
        int day = days[month];
        if (month == 2 &&((year % 4 == 0 && year % 100 != 0) || (year%400 == 0)))
        {
            day += 1;
        }
        return day;
    }
    Date(int year = 2022,int month = 9 ,int day = 25)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    // ==运算符重载
    // bool operator==(Date* this, const Date& d2) 这是我们把隐藏的this加上的函数形参原型
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d)
    {
      return _year == d._year &&_month == d._month &&_day == d._day;
    }
    // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
    Date& operator+=(int day)
      {
        _day +=day;
        int monthdays = GetMonthDay(_year, _month);
          while(_day > monthdays)
          {
              _day -= monthdays;
              _month++;
              if(_month == 13)
              {
                  _month = 1;
                  _year++;
              }
              monthdays = GetMonthDay(_year, _month);
          }
        return *this;
      }
    //Date(const Date d)//错误写法，会无限递归
    Date(const Date& d)//正确浅拷贝写法
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    void Print()
    {
        cout<<_year <<"-" << _month<<"-"<<_day<<endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{

//    Date d1;
//    d1.Print();
//    Date d2;
//    d2.Print();
//    cout<<(d1 == d2)<<endl;
    Date d3;
    d3.Print();
    d3+=50;

    d3.Print();
    return 0;
}

赋值运算符重载
1. 赋值运算符重载格式
参数类型：const 类类型&，传递引用可以提高传参效率
返回值类型：类类型&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

我们可以重载赋值运算符，不论形参的类型是什么，赋值运算符都必须定义为类的成员函数。

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注
意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符
重载完成赋值。

注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必
须要实现。

const成员

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

class Test
{
public:
    //打印年份，月份，天数
    void DisPlay()const
    {
        cout << _year << '/' << _month << '/' << _day << endl;
        
    }
private:
    int _year;
    int _month;
    int _day;
};

编辑器会对const函数进行处理

class Test
{
public:
    //打印年份，月份，天数
    void DisPlay(const Test* this)
    {
        cout << this->_year << '/' << this->_month << '/' << this->_day << endl;
        
    }
private:
    int _year;
    int _month;
    int _day;
};

如果一个const类 去调用一个非const函数，是调用不了的，编辑器会报错的，对于我们不会修改的函数，建议都加const，这样的话，const成员的类也可以去调用const的函数，非const成员的类 也可以调用const函数。

 

class Test
{
public:
    Test(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //打印年份，月份，天数
    void DisPlay()const
    {
        cout << _year << '/' << _month << '/' << _day << endl;
    }
    //打印年份，月份，天数
    void DisPlay()
    {
        cout << _year << '/' << _month << '/' << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};


int main()
{
    Test d1(2022,10,13);
    d1.DisPlay();
    const Test d2(2022,10,13);
    d2.DisPlay();
    return 0;
}

请思考下面的几个问题：
1. const对象可以调用非const成员函数吗？
2. 非const对象可以调用const成员函数吗？
3. const成员函数内可以调用其它的非const成员函数吗？
4. 非const成员函数内可以调用其它的const成员函数吗？

1:不可以，2:可以，3:不可以，4:可以。

取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Test
{
public:
    //取地址运算符重载
    Test* operator&()
    {
        return this;
    }
    //const取地址运算符重载
    const Test* operator&()const
    {
        return this;
    }
private:
    int _year;
    int _month;
    int _day;
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需
要重载，比如想让别人获取到指定的内容！