【C++】 类和对象--（二）-类的六个默认成员函数

前言

本文是小编对 C++ 类和对象学习总结的第二篇，文章将由浅入深带大家学习 C++ 类和对象，那么话不多说，大家请看下文。

一、类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。

class Data { };

二、构造函数

2.1 概念

class Data
{
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(2024,9,1);
    d1.Print();
    
    Date d2;
    d2.Init(2024,9,2);
    d2.Print();
    
    return 0;
}

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

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

2.2 特性

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

• 其特征如下：
  1、函数名与类名相同。
  2、构造函数无返回值。
  这里的无返回值不是说返回值为 void ，而是真的没有返回值。
  3、对象实例化时编译器自动调用对应的构造函数。
  4、构造函数可以重载。

class Data
{
public :
    // 1.无参构造函数
    Date ()
    {}
    
    // 2.带参构造函数
    Date (int year, int month , int day )
    {
        _year = year ;
        _month = month ;
        _day = day ;
    }
    
private :
    int _year ;
    int _month ;
    int _day ;
};

void TestDate()
{
    Date d1; // 调用无参构造函数
    Date d2 (2024, 1, 1); // 调用带参的构造函数
    
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    // 如以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // Date d3();
}

5、 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义，编译器将不再生成。

class Date
{
public:

//  Date()    //函数一
//  {
//      _year = 0;
//      _month = 1;
//      _day = 1;
//  }
    
// 如果用户显式定义了构造函数，编译器将不再生成默认构造函数
    Date (int year, int month, int day)   //函数二
    {
        _year = year;
        _month = month;
        _day = day;
    }
/*

     //更好的方式->全缺省 （上面两种方式的合二为一）
     Date (int year = 0, int month = 1, int day = 1)   //函数三
    {
        _year = year;
        _month = month;
        _day = day;
    }
*/
private:
    int _year;
    int _month;
    int _day;
};

void Test()
{
     Data d;  //此处编译出错，要自己定义一个无参构造函数或者不要函数二才能跑过。
    // 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数(无参构造函数)；（函数一）
    //如果显示定义了构造函数（函数二），编译器就不会自动生成默认构造函数了,还想用无参构造函数,就只能自己定义一个无参构造函数（函数一）
    
    //如果定义了全缺省的构造函数（函数三）；则创建对象时可以不传参，或者传一个/两个/三个参，如下：
    //Data d;    //不传值时使用缺省值（0，1，1）作为初始化数据
    //传值时，传的使用传的值作为初始化数据，其他不传的用缺省值
    //Data d1(2024)
    //Data d2(2024,9)
    //Data d3(2024,9,1);
}

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

// 默认构造函数
class Date
{
public:
    Date()
    {
        _year = 2024 ;
        _month = 1 ;
        _day = 1;
    }
    
    Date (int year = 2024, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    
private :
    int _year ;
    int _month ;
    int _day ;
};

// 以下测试函数能通过编译吗？
//答案：不能，上面两个函数虽然构成重载，但是它们两个不能同时存在，因为如果同时在，
//下面创建 d1 会存在歧义，因为创建 d1 既可以调用无参构造函数，也可以调用全缺省构造函数
//这里它不知道调谁，所以这种选择是不允许发生的
void Test()
{
    Date d1;
}

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

• 解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如 int / char …，自定义类型就是我们使用 class / struct / union 自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员 _t 调用的它的默认成员函数 (也就是说默认生成的无参构造函数,针对内置类型的成员变量没有做处理,针对自定义类型的成员变量,调用它的构造函数初始化)

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

class Date
{
private:
    // 基本类型(内置类型)
    int _year;
    int _month;
    int _day;
    
    // 自定义类型
    Time _t;
};

int main()
{
    Date d;
    return 0;
}

8、成员变量的命名风格

// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
    Date(int year)
    {
        // 这里的year到底是成员变量，还是函数形参？
        year = year;
    }    
private:
    int year;
};

// 所以我们一般都建议这样
class Date
{
public:
    Date(int year)
    {
        _year = year;
    }
private:
    int _year;
};

// 或者这样。
class Date
{
public:
    Date(int year)
    {
        m_year = year;
    }
private:
    int m_year;
};
// 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

三、析构函数

3.1 概念

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

3.2 特性

析构函数是特殊的成员函数。

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

class Data
{
public:
    void Data()
    {
        _year = 0
        _month = 1;
        _day = 1;
    }
    void Print()
    {
        cout <<_year<< "-" <<_month << "-"<< _day <<endl;
    }
    
    ~Data()
    {
        cout << "~Data()" << endl;
    }
    
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
//析构：对象生命周期到了以后，自动调用，完成对象资源清理工作（如代码二），注意：不是完成 d1 和 d2 的销毁（d1、d2 在函数栈帧里面，函数结束随着栈帧就销毁了）
    Date d1;
    Date d2;
    return 0;
}

代码二如下：（并不是所有对象都需要清理，但通常动态开辟的东西、文件等等在对象销毁时并不会主动释放空间，这时候就需要清理了，否则进程资源就会越来越少）

typedef int DataType;
class Stack
{
public :
    //对象创建时自动调用完成初始化工作
    Stack (int n = 10)
    {
        _a = (DataType*)malloc(n * sizeof(DataType));
        assert(_a);
        _size = 0;
        _capacity = n;
    }
    //资源清理
    //对象生命周期到了以后，完成清理工作（并不是所有对象都需要清理，通常动态开辟的东西、文件等等就需要清理，否则进程资源就会越来越少）
    ~Stack()
    {
        if (_a)
        {
           free(_a ); // 释放堆上的空间
           _a = NULL; // 将指针置为空
           _capacity = 0;
           _size = 0;
        }
    }
private :
    int* _a ;
    size_t _size;
    size_t _capacity;
};

int main()
{
    Stack s1;
    Stack s2;
    //析构时先析构s2,再析构s1,后进先出
}    

• 5、关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对内置类型不会做什么事情, 对自定义类型成员会调用它的析构函数。

class String
{
public:
    String(const char* str = "jack")
    {
        _str = (char*)malloc(strlen(str) + 1);
        strcpy(_str, str);
    }
    ~String()
    {
        cout << "~String()" << endl;
        free(_str);
    }
private:
    char* _str;
};

class Person
{
private:
    String _name;
    int _age;
};

int main()
{
    Person p;
    return 0;
}

四、 拷贝构造函数

4.1 概念

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

4.2 特征

• 拷贝构造函数也是特殊的成员函数，其特征如下：
  1 、拷贝构造函数是构造函数的一个重载形式。
  2、 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    
    //Date(const Date& d)  //用这个不会发生出错
    Date(Date d)  //用这个代码编译时会出错，引发无穷递归问题，解释如下图
    {   
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;  
};

int main()
{
    Date d1;
    //下面这两个用法是一样的,都是调用拷贝构造
    Date d2(d1);
    Date d3 = d1;  //如果是 Date d3; d3 = d1;则是赋值操作

    return 0;
}

class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    
    Date(const Date& d)
    {   
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;  
};

//可以用这两个函数通过调试监视来看到(不用引用时)传参过程是一个拷贝构造

void Func(Date d)  //这里传参会调用拷贝构造  
{}
/*这里也不会有问题,因为上面拷贝构造函数是用引用的,所以传参
调用拷贝构造时也不会发生无穷递归,如果不用引用,就有问题了,如上图*/

              
void Func(Date& d)  //这里不会调用拷贝构造
{}
//这里的话会更好,因为引用可以减少拷贝,提高效率,小编之前文章有详解     

int main()
{
    Func(d1);
    return 0;
}

我们再来看一个问题：我们注意到上面代码的拷贝构造是这样写的（Date(const Date& d));这里加了一个 const , 这是为什么呢？我们来看看下面代码

class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
   {
        _year = year;
        _month = month;
        _day = day;
   }
    //Date d2(d1);
    Date(Date& d)  //Date(const Date& d)；
    {   
        _year = d._year;
        _month = d._month;
        d._day = _day;  //假设万一你这里写错了，写反了，就会引发随机值，可自行运行代码查看，这里不做显示
/*原因是啥呢：是由于这里 d1 传给了 d, d就是 d1,而d2是this，
这里反过来将d2(_day) 赋值给了 d1(d._day);而d2(_day)没有初始化，
本来就是一个随机值，所以就把它们全部置成随机值了 */      
    }
    
     void Print()
    {
        cout <<_year<< "-" <<_month << "-"<< _day <<endl;
    }   
private:
    int _year;
    int _month;
    int _day;
};
 int main()
 {
     Date d1(2024,9,1);
     Date d2(d1);
     Date d3 = d1;
     d1.Print();
     d2.Print();
     d3.Print();
     return 0;
 }

如何避免上面这种问题呢，加 const 就可以解决了（Date(const Date& d))；加 const 之后 d 就不能被修改，如果出现上面这种误写，编译器就会直接检查出错误，让你改正。（所以现实当中传参的时候（除了 swap 那样的函数） ，一般都建议用 const 的引用，保护原数据不被修改）

3 、若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
   {
        _year = year;
        _month = month;
        _day = day;
   }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;
    // 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
    Date d2(d1);
    return 0;
}

五、赋值操作符重载

5.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

• 函数名字为：关键字 operator 后面接需要重载的运算符符号。
• 函数原型：返回值类型 operator操作符 (参数列表)
  参数和返回值是根据场景来定义的。

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

如果我们想要比较两个日期是否相等（或者是比较大小），除了写一个 IsEqual 这样的函数来判断，还有没有更好的办法呢，我们来看看下面代码：

// 全局的operator==（无法保证封装性）
class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
//private:  //如果是私有的，下面的重载全局函数就编译出错了，要编过，可以用友元，或者重载成成员函数
    int _year;
    int _month;
    int _day;
};

/*bool IsEqual(const Date& d1, const Date& d2)
{
    return d1._year == d2._year;
    && d1._month == d2._month
    && d1._day == d2._day;
}*/

// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
//运算符有几个操作数，operator 重载的函数就有几个参数
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year;
    && d1._month == d2._month
    && d1._day == d2._day;
}

//自定义类型是不能用运算符的，要用就得实现重载函数，自定义类型用的时候等价于调用这个重载函数
void Test ()
{
    Date d1(2024, 9, 26);
    Date d2(2024, 9, 27);
    cout<<(d1 == d2)<<endl;  //d1 == d2;编译器会处理成-> operator==(d1,d2);
    //operator==(d1,d2); //这样写也可以，但是一般不这样写，因为可读性不好
}

第二种思路如下：

//重载成成员函数：
class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    
// 这里需要注意的是，左操作数是this指向的调用函数的对象
//d1 == d2;相当于 d1.operator==(&d1,d2);
bool operator==(const Date& d2)
//这里编译器会处理成bool operator==(Date* this, const Date& d2)，有个隐含的this指针
{
    return _year == d2._year;
    && _month == d2._month
    && _day == d2._day;
}
private:
    int _year;
    int _month;
    int _day;
};
void Test ()
{
    Date d1(2024, 9, 26);
    Date d2(2024, 9, 27);
    cout<<(d1 == d2)<<endl;  // d1 == d2;编译器转换成 d1.operator==(d2);
    // d1.operator==(d2); //这样写也可以，就是可读性不好
    // d1.operator==(&d1,d2);不能这样写
}

5.2 赋值运算符的重载

class Date
{
public :
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date (const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    void Print()
    {
        cout <<_year<< "-" <<_month << "-"<< _day <<endl;
    }
    
    Date& operator=(const Date& d)
    {
        if(this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }
private:
    int _year ;
    int _month ;
    int _day ;
};
int main()
{
    Date d1;
    d1.Print();
    Date d2(2024,9,1);
    d2.Print();
    d1 = d2;
    d1.Print();

    Date d3(2024 1.1);
    d3.Print();
    d1 = d2 = d3;
    d2.Print();
    d1.Print();
    return 0;
}   

赋值运算符主要有四点：

• 1.参数类型（第一个形参默认是 this 指针，第二个形参是赋值运算符的右操作数）
  this 指针是默认的，我们管不了。第二个参数类型我们建议加上引用，减少拷贝构造，避免额外开销（传值传参会额外调用一次拷贝构造），另外建议用 const 对第二个参数参数进行修饰，因为函数体内不会对赋值运算符的右操作数（也就是第二个参数）进行修改，加上 const 避免误操作。
• 2.返回值类型
  首先，返回值应该是赋值运算符的左操作数，也就是 this 指针指向的对象，因为如果我们只是进行 d1 = d2 这种赋值操作，没有返回值是可以的，但是为了支持连续赋值（ d1 = d2 = d3)，返回值就必须是同类型了，因为不同类型是不支持赋值操作的，例如 d2 = d3 的返回值如果不是同类型，就不能赋值给 d1。所以上面代码 我们用 Date 接收返回值，又因为 出了函数的作用域 *this 这个对象还在，所以我们用引用返回（Date&)，减少拷贝。
• 3.检测是否自己给自己赋值
  自己给自己赋值是没有意义的，例如 d1 = d1; 这种操作我们没必要进行，所以在进行赋值操作时我们可以先判断是否有出现这种情况。如上面代码的：if(this != &d)
• 4.返回*this
  赋值操作完成后，我们应该返回赋值运算符的左操作数，例如 : i = j = k; 的赋值步骤是，将 k 赋值给 j ,返回 j 的值，再把 j 赋值 给 i ，返回 i 的值，由于左操作数我们只能通过 this 指针访问，所以我们要返回 *this。
• 5.一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
  也就是说我们不实现时，编译器生成的拷贝构造和赋值运算符重载（operator =）；会完成按字节序的值拷贝（也就是浅拷贝）

浅拷贝：将对象按一个一个字节拷过去。

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _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(2024，10， 1);
    d1.Print();
    d2.Print();

/* 上面没有实现赋值运算符重载，这里d1调用的是编译器生成的
默认赋值运算符重载operator=完成拷贝，d2和d1的值也是一样的。*/
    d1 = d2；
    d1.Print();
    return 0;
}

那么编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了。也就是说有些类，我们是不需要自己实现拷贝构造和赋值运算符重载函数（operator =）的，因为编译器生成的就可以直接用，比如：Date 日期类就是这样。

但是有些类是需要我们自己实现的（深拷贝），否则就会（造成同一块空间释放两次而）引发程序崩溃，例如下面这个程序：

// 这里会发现下面的程序会崩溃掉？这里就需要用深拷贝去解决。
class Stack
{
public :
    Stack (int n = 10)
    {
        _a = (int*)malloc(n * sizeof(int));
        assert(_a);
        _size = 0;
        _capacity = n;
    }
    ~Stack()
    {
        if (_a)
        {
           free(_a );
           _a = nullptr; 
           _size = _capacity = 0;
        }
    }
private :
    int* _a ;
    size_t _size;
    size_t _capacity;
};

int main()
{
    Stack st1;
    Stack st2(st1);
/*上面我们没有自己写拷贝构造，但是这里也完成了拷贝，因为是调用
编译器生成的拷贝构造完成的，*/
    
    //Stack st3;
    //st3 = st1;
/*上面我们也没有自己写赋值运算符重载，但是这里也完成了赋值功能，这里也是调用编译器生成的 operator = 完成的 */
    
    return 0;
}

为什么程序会崩溃呢？这里是 C++ 里面的很重要的浅拷贝问题 。
小编来解释一下：这里创建 st1 的时候，我们看到构造函数给 st1 的数组 malloc 了一块空间，st1._a 存储的就是这块空间的地址，接下来我们用 st1 来拷贝构造初始化一个 新的对象 st2 , 这时候调用的是编译器生成的拷贝构造函数来完成的，所以 st1 里面的12个字节的值会依次拷贝给 st2 的 12 个字节上面（字节序的值拷贝，也是浅拷贝），这时候问题就来了，当拷贝完成以后，st2._a 里面的值 就和 st1._a 的是一样了（地址一样），也就是说 st1 , st2 两个不同的对象的指针都指向了同一块空间，这时候就导致两个问题：1、修改 st1, st2也会被修改，修改 st2, st1也会被修改(指向空间一样，互相影响）。2、出了函数的作用域，会调用析构函数，这时候会先析构 st2( free( st2._a ) ) , 再析构 st1 ( free( st1._a ) ) ,这样的话，同一块空间就被释放了两次了（这也是导致崩溃的原因）。下面的赋值同理。那这里我们怎么解决呢？自己去实现深拷贝的拷贝构造和 赋值运算符重载函数（不用编译器生成的）！这个我们之后的文章会提到。

小贴士：我们通过调试可以看到 st1 ,st2, st3 的地址是一样的。

六、 默认拷贝构造与赋值运算符重载的问题

区别：
拷贝构造函数：用一个已经存在的对象去构造初始化另外一个新创建的对象。
赋值运算符重载：两个对象都已经存在，将一个对象赋值给另外应该对象的操作。

Date d1(2024,8,14);
Date d2(2024,8,15);

d1 = d2;    //两个对象都已经存在且初始化好了，现在把 d2 赋值给 d1；

//下面两个写法是等价的，相当于编译器都会识别成调用拷贝构造完成的
Date d3(d1);  //拷贝构造：d3 还不存在，构造 d3 时用 d1 来初始化
Date d4 = d1;  //注意，这里也是拷贝构造，构造 d4 时用 d1 来初始化

七、const成员函数

7.1 const修饰类的成员函数

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

语法： 返回类型 函数名 （参数类型）const {}

我们来看看一段代码

class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void Print()
    {
        cout <<_year<< "-" <<_month << "-"<< _day <<endl;
    }
    
private:
    int _year;
    int _month;
    int _day;
};

void f(const Date& d)
{
    d.Print();  //我们会发现这里程序编译出错，为什么 d 调用不了 Print 呢？
}

int main()
{
    Date d1(2024,10,1);
    d1.Print();
    return 0;
}

出错原因如下：

小贴士：如果 成员函数内部不会对 this 指针指向的对象进行修改的话，都建议用 const 修饰成员函数。

我们来看看常见的几个面试问题：

• 1、const 对象可以调用非 const 成员函数吗？ （不可以）
  非 const 成员函数 , 即成员函数隐含的 this 指针没有被 const 修饰，我们传入一个 const 修饰的对象，被 没有被const 修饰的 this 指针接收，很明显是不可以的。（权限放大了，对象不能修改，传入之后却可以修改了，不行！）
• 2、非 const 对象可以调用 const 成员函数吗？ （可以）
  const 成员函数 , 即成员函数隐含的 this 指针是被 const 修饰的，我们传入一个非 const 修饰的对象，用 const 修饰的 this 指针接收，这样是可以的。（权限缩小，对象能修改，传入之后就不能修改了，可以的！）
• 3、const 成员函数内可以调用其它的非 const 成员函数吗？ （不可以）
  只要调用成员函数都涉及 this 指针（除了静态的）；const 成员函数调用非 const 成员函数，相当于把一个被 const 修饰的 this 指针 传给一个没有被 const 修饰的 this 指针，属于权限的放大，是不可以的。
• 4、非 const 成员函数内可以调用其它的 const 成员函数吗？ （可以）
  非 const 成员函数调用 const 成员函数，相当于把 一个 没有被 const 修饰的 this 指针 传给一个被 const 修饰的 this 指针，属于权限的缩小，是可以的。

3、4 点的图如下：

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

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

class Date
{
public :
    Date(int year = 0, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    Date* operator&()
    {
        return this ;
    }
    const Date* operator&()const
    {
        return this ;
    }
    
private :
    int _year ; 
    int _month ;  
    int _day;
};

int main()
{
    Date d1;
    Date d2;
    const Date d3;

    cout << &d1 << endl;
    cout << &d2 << endl;
    cout << &d3 << endl;
    
    return 0;
 }

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

//不想让别人取到地址，就让他获取空指针
    Date* operator&()
    {
        return nullptr ;
    }
    const Date* operator&()const
    {
        return nullptr ;
    }

结尾

本节到此已经全部结束，本节我们讲述了关于 C++ 类和对象的六个默认成员函数，相信看到这里的你们也收获很多,关于以上内容有错误或者欠缺的也欢迎大家踊跃指出，那最后，喜欢小编的文章的话，记得点赞评论收藏+关注哦，拜拜，我们下篇文章见！