本文主要介绍类里面的六大默认成员函数

---

前言

今天，我们将深入学习类和对象的六个默认成员函数，分别为：构造函数、析构函数、拷贝构造函数、赋值操作符重载、取地址与const取地址操作符重载

---

类的6个默认成员函数

当类中一个成员没有时，则为空类。

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

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

它们是特殊的成员函数，特殊的点很多：如果自己没有实现，编译器会自己生成，不一定效果最佳，但有一定价值。

它们的作用很强大，比如写 C 语言时，写一个栈，可能一顿操作猛如虎，但是忘记初始化和销毁，不是崩溃就是内存泄漏。C++ 针对这种情况设计了构造函数（初始化）和析构函数（清理）。

同理，其他成员函数也都是根据场景设计，弥补 C 中的不足。

1、构造函数

1.1 概念

就拿日期类来说：

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, 7, 5);//对象1初始化d1.Print();Date d2;d2.Init(2022, 7, 6);//对象2初始化d2.Print();return 0;
}

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

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

我们来动手写一下：

class Date
{
public:Date(){_year = 0;_month = 1;_day = 1;}Date(int year, int month, int day){_year = year;_month = month;_day = day;}private:int _year;int _month;int _day;
};int main()
{Date d1; // 自动调用第一个构造函数Date d2(2023, 1, 31); // 传参调用第二个构造函数return 0;
}

构造函数名称和类名相同，所以名字为 Date ，函数无返回值。

构造函数会自动调用；若需要主动调用，只要 Date() 即可，括号中为参数。

验证没问题，d1 被自动调用，d2 主动调用，两者都初始化完毕；它们互不冲突，且构成函数重载 。而两个函数其实有些繁琐，根据 缺省参数 的特性，我们发现其实这两个函数可以合并成一个函数：

Date(int year = 0, int month = 1, int day = 1)
{_year = year;_month = month;_day = day;
}// 调用
Date d1;
Date d2(2023, 1);
Date d3(2023, 1, 31);

使用全缺省参数，使调用更加多样。但是使用这种实现方式，须注意二义性 ，例如这里再写一份无参的构造函数 Date() ，就会造成二义性，语法能编译通过，但是调用不知道调用哪一个。

1.2 特性

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

其 基本特征 如下：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数；一旦用户显式定义，编译器将不再生成默认无参构造函数。编译器默认生成的构造函数对内置类型不做处理，对自定义类型会调用该成员的默认构造函数。
6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（无参构造函数、全缺省构造函数、没写编译器默认生成的构造函数，都可以认为是默认构造函数）

下面我们对每个特点逐个讲解
对于特点1-4：

class Date
{
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(2015, 1, 1); // 调用带参的构造函数// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)Date d3();
}

🐯对于特点5：

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

编译器默认生成的构造函数为空函数。C++ 中把类型分为两类，内置类型（基本类型：int/char/double/内置类型数组/指针），自定义类型（struct/class定义的类型）。

当我们不写构造函数时:
1：对于内置类型不做初始化处理（为随机值）
2：对于自定义类型会调用它自动生成的默认构造函数（不用参数就可以调用）构造初始化（先对成员进行构造，再对整体进行构造）。但是如果没有默认构造函数就报错。

下面我们验证：若用户定义了构造函数，则编译器则不生成默认无参构造函数，若调用方式错误，则会报错。

class A
{
public:A(){cout << "A()" << endl;_a = 0;}
private:int _a;
};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;A _aa;
};int main()
{Date d1;return 0;
}

在 Date 类的成员变量中，创建 A 的类对象，且 A 具有无参构造函数。

在当前情况下，执行是没问题的，其一是因为 d1 调用其构造函数，需要将 自定义类型 _aa 初始化；其二是 _aa 又会调用其默认构造函数，此刻因为 A 定义的 构造函数无参 ，A _aa 可以通过编译，并调用构造函数打印，完成初始化。

但是如果给 A 的构造函数增加参数 ：

就报错了，因为此刻 _aa 没有默认构造函数调用（因为定义的是带参的构造函数，你没有传参），且由于自定义了构造函数，编译器也没有自动生成 。

总结：C++ 我们不写编译器默认生成构造函数，函数设计的不好，没有对内置类型与自定义类型统一处理（不处理内置类型成员变量，只处理自定义类型成员变量）

所以在 C++ 11 时，对于内置类型打了一个补丁：内置类型成员变量在类中声明时可以给默认值（缺省值）

_year 给了 100 ，所以有值，其他的没有给，所以用默认值（缺省值）。

6）无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个（无参构造函数、全缺省构造函数、没写编译器默认生成的构造函数，都可以认为是默认构造函数）

2、析构函数

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没的？

2.1 概念

析构函数：与构造函数功能相反，析构函数不是完成对 对象 本身的销毁，局部对象销毁工作是由编译器（栈）完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

析构函数的函数名是在类名前加上字符 ~ ，例如基于 Date 类写一个析构函数：

~Date()
{// Date 类没有资源需要清理，所以当前 Date 类不写闲析构函数都可以cout << "~Date()" << endl;
}

2.2 特性

其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
   注意：析构函数无参、无返回类型，因此，析构函数 不构成函数重载 ，因为函数无参，所以一个类只能有一个析构函数 。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数
5. 若没有定义析构函数，则编译器会自动生成,析构函数对于内置类型的成员变量不做处理，对于自定义类型会去调用它的析构函数。

虽然 Date 类不需要析构函数，但是有的情景下就需要，比如 Stack（栈），我们简单写一个栈类：

class Stack
{
public:Stack(int capacity = 4) // 构造函数，缺省1参数，不传参默认给 4{_a = (int*)malloc(sizeof(int) * capacity);if (_a = nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}private:int* _a;size_t _top;size_t _capacity;
};int main()
{Stack s1;Stack s2;return 0;
}

对于栈来说，就需要析构函数，因为对于 s1, s2 为 main 中局部变量，但是它们指向的空间是 malloc 动态开辟的，所以必须释放，否则会造成内存泄漏。

所以必须写出析构函数 ：

~Stack()
{free(_a);_a = nullptr;_top = _capacity = 0;
}

通过析构函数来完成栈的销毁，而当局部变量出作用域时，系统会自动调用析构函数 ：

我们知道构造是 s1 先构造，再构造 s2 ，但是析构的顺序呢？，对于在栈帧中的对象，因为 s1 先压栈，s2 再压栈，所以会先出 s2 ，就先对 s2 进行析构，它们的析构顺序是相反的 ，观察 this 指针 ：

🐯对于特点5：
5)若没有定义析构函数，则编译器会自动生成，**但是自动生成的析构函数会干什么？它会销毁栈吗？ 并不会。析构函数对于内置类型的成员变量不做处理，对于自定义类型会去调用它的析构函数。

可能有小伙伴会疑惑，C++ 为什么多此一举搞自动生成析构函数，它又不对内置类型处理，没什么用啊？

其实也不能这么说，因为对于内置类型，就拿指针来说：

假设拿栈来说，这个指针就是要被释放，置空；如果我一看到指针都释放，都默认用 free ，如果不是 free 了不是动态开辟的指针呢？那不完了，所以对内置类型不处理这时反而是保护我们的程序。
其实也不能这么说，因为对于内置类型，就拿指针来说：

而对于自定义类型的成员变量去调用它的析构函数是很有用的，就比如这题

之前用 C 语言实现时，我们需要对其完成初始化，手动销毁，但是现在就不用了，我们完全可以通过构造函数和析构函数的特性来完成自动处理 ：

class Stack
{
public:Stack(int capacity = 4) // 构造{_a = (int*)malloc(sizeof(int) * capacity);if (_a = nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}~Stack() // 析构{free(_a);_a = nullptr;_top = _capacity = 0;}
private:int* _a;size_t _top;size_t _capacity;
};class MyQueue
{
public:void push(int x) {}
private:Stack pushST;Stack popST;
};int main()
{MyQueue mq; // 自动调用构造和析构return 0;
}

这时对于自定义类型 mq ，就不用写了。因为对于默认生成的构造函数和析构函数，会自动调用它的构造和析构。这个自定义类型是 Stack ，于是就会自动调用，自动完成初始化和销毁。所以其实默认的析构函数还是很有用的！

3 、拷贝构造函数

对于内置类型，编译器可以直接对数据完成拷贝；但是在对自定义类型进行拷贝时，编译器是不适合直接拷贝的，而这时可以使用拷贝构造函数。

3.1 概念

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

3.2 特性

拷贝构造函数也是特殊的成员函数，它的名字也为类名，和构造函数构成函数重载

其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是本类类型对象的引用(一般常用const修饰)，使用传值方式编译器直接报错，因为会引发无穷递归调用。
3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
   字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。
4. 只要自定义构造函数或者拷贝构造函数，都不会生成构造函数，自定义类型成员会调用它的拷贝构造
5. 拷贝构造我们不写生成的默认拷贝构造函数对于内置类型和自定义类型都会拷贝处理。但是处理细节和构造和析构是不一样的。

下面我们对每个特逐个讲解
🐯特点2：拷贝构造函数的参数只有一个且必须是本类类型对象的引用，使用**传值方式编译器直接报错，**因为会引发无穷递归调用。

验证传值传参报错：

一定要加上引用才不会报错 ：

Date(Date d) // 拷贝构造函数
{_year = d._year;_month = d._month;_day = d._day;
}

解析传值传参会发生无穷递归：

仔细观察拷贝构造函数传参的过程，是不是又是 Date date(d1) ，在传参时，是不是无形中又调用了拷贝构造函数？

因为我们的 date 形参就是原对象 d1 ，而传参过来，则是一份和原先对象一模一样的对象，这个对象不存在，所以我们需要调构造函数，但是这里的构造函数是拷贝构造函数，所以我们需要先进行拷贝构造，而拷贝构造到下一层也是相同的原理，就是在一直拷贝构造不存在的形参，从而形成死递归 。

但是使用引用传参就没事了，因为 date 此刻变为 d1 的别名，这时就不存在 拷贝对象不存在从而继续拷贝的情况 。此刻就可以顺利进入拷贝构造函数。

所以拷贝构造参数一定不能为传值，要传引用！我们也可以抽象出一个概念：定义类型传值传参就是拷贝构造 。

而对于拷贝构造函数的参数，一般加 const 修饰 ，因为拷贝构造函数的功能可能会写反，比如：

Date(Date& d) // 拷贝构造函数
{d._year = _year; // 写反了_month = d._month;_day = d._day;
}

这时不仅没有拷贝构造成功，还把 d1 改了：

这就错误了，但是加上 const 修饰就没事：

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

class Stack
{
public:Stack(int capacity = 4){_array = (int*)malloc(sizeof(int) * capacity);if (_array == nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}void Push(const int& data) {_array[_top] = data;_top++;}~Stack(){free(_array);_array = nullptr;_top = _capacity = 0;}private:int* _array;size_t _top;size_t _capacity;
};int main()
{Stack st1;st1.Push(1);Stack st2(st1);return 0;
}

不出意外，当我们进行操作时，程序奔溃了 ：

因为 st1 和 st2 指向的同一块空间，释放了两次。

这里我们使用的默认拷贝构造就是编译器自动处理的，很明显这里不行。而如果要实现正确的拷贝构造，需要深拷贝。所谓深拷贝，就是让它们有独立的空间，就比如这里的 Stack ，就是让 _array 指向不同的空间，使得它们之间的操作互不影响，接下来，我们简单写一下深拷贝：

class Stack
{
public:Stack(int capacity = 4){_array = (int*)malloc(sizeof(int) * capacity);if (_array == nullptr){cout << "malloc fail" << endl;exit(-1);}_top = 0;_capacity = capacity;}Stack(const Stack& st){_array = (int*)malloc(sizeof(int) * st._capacity);if (_array == nullptr){cout << "malloc fail" << endl;exit(-1);}memcpy(_array, st._array, sizeof(st._array) * st._top); // 拷贝 st1 指向空间的值到 st2 指向的空间_top = st._top;_capacity = st._capacity;}void Push(const int& data){_array[_top] = data;_top++;}~Stack(){free(_array);_array = nullptr;_top = _capacity = 0;}private:int* _array;size_t _top;size_t _capacity;
};

这时就没有问题了，st1 和 st2 指向了不同的空间：

由此，我们总结出一个结论：当自己实现了析构函数释放空间，就需要实现拷贝构造（深拷贝），而深拷贝我们之后也会详细讲解。

🐯特点4:只要自定义构造函数或者拷贝构造函数，都不会生成构造函数，自定义类型成员会调用它的拷贝构造

类中自定义类型成员会自动调用它的拷贝构造 ：

class A
{
public:A() {}A(const A& a) // 拷贝构造{cout << "A(const A&)" << endl;}
};class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}~Date(){cout << "~Date()" << endl;}private:int _year;int _month;int _day;A _aa; // 自定义类型
};int main()
{Date d1;Date d2(d1);return 0;
}

由于 只要自定义构造函数和拷贝构造函数就不生成默认构造函数 的原因，所以需要定义一下构造函数A() {}。

对 d2 进行拷贝构造时，其中 _aa 成员变量，会自动调用它本身的拷贝构造。

拷贝构造会经常存在，比如返回时，或传参时，都会发生拷贝构造：

例如这里，就是在 a2 传参时，拷贝构造成了参数 a ，并且在 a 返回时，拷贝构造给了临时变量。拷贝构造是有消耗的，所以用好引用很重要 。

3.3 使用场景

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

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

4、运算符重载

4.1 规则

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

运算符重载：

• 函数名字为：关键字operator后面接 需要重载的运算符符号
• 函数原型：返回值类型 operator操作符(参数列表)

返回值与参数：

• 对于返回值：不同的运算符重载函数，返回值是不同的，例如 > 就是 bool 类型；- 就是 int 类型
• 对于参数操作数有几个操作符，就有几个操作数

我们依然围绕日期类进行讲解，首先写一下日期类：

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(2023, 2, 3);Date d2(2023, 3, 4);return 0;
}

创建 d1 和 d2 两个对象，时间分别为 2023.2.3 和 2023.3.4 ，如何比较它们的天数的先后，或者是算它们中间相差的天数？

对于平常情况下，我们可以手算，但是对于计算机呢？如何直接用运算符来比较？可不可以直接比较它们的先后？可以不可以让 d2 的天数直接减去 d1 的天数？例如 d1 > d2 ，d2 - d1 ？

在 C++ 中，只支持对内置类型的运算符计算，并不支持直接对自定义类型进行运算符计算
但是通过运算符重载可以达到这个效果 。

对于一个比较大小运算符重载的参数需要注意几点：

bool operator>(const Date& d1, const Date& d2);

重载的是 > ，对于这个符号有两个操作数；参数写成引用的形式，减少空间的消耗；加上 const 修饰，也防止这两个对象由于引用的原因被修改。

接下来，我们写出这个运算符重载：

但是这迎来一个问题 ：运算符重载在类外部访问不到成员变量，这样就使得运算符重载不起作用了。那么我们就要相除解决方案。

方案1（可以但不推荐）：将成员变量变为公有

这时，调试，然后到 d1 > d2 ，f11 进入运算符重载：

对于这边的调用有两种方式：

编译器看到自定义类型 d1 > d2 去找是否重载了运算符，如果找到了，就转换为 operator>(d1, d2) 调用函数，找不到就 报错：

如果这时候我们把 operator> 屏蔽掉：

方案2（推荐）：将运算符重载函数写在类里面
但是这里会有一个问题：

写成成员函数时，成员函数默认会有一个 this 指针，但是对于运算符重载的参数个数等于操作数个数，> 有两个，现在就有三个了，所以错了。

例如如果直接调用 operaror> 函数时：

Date d1;
d1.operator>(d2);

d1 作为 this 指针被传过去，d2 被作为另一个参数，但是这里对于我们当前的函数来说，有三个参数：this, d1, d2 ，参数不匹配了！

所以需要修改：

(可以写成 this->_year，因为 this 指针可以省略)

这时 d1 > d2 ，会先去到类的成员里面找，找到了转换为 d1.operator>(d2)，若类中没找到，再到全局找，找到转换为 operator>(d1, d2) ，进行调用。

对于上面两种 operator> 全局的和类中的可以同时存在（参数不同构成重载），若同时存在，则调用类中成员的，和就近原则没什么关系，取决于编译器的实现机制；但是这种情况一般不存在，因为成员变量一般都是 private 私有的，全局的并没有用。

对于运算符重载的规则：

• 不能通过连接其他符号来创建新的操作符 ：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
• [.*](没用过类似于访问解引用，背住) :: sizeof ?:(三目运算符) .(访问自定义类型) 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。
• 返回值类型不一定是内置类型，例如 Date operate++() 返回值还是个日期
• 运算符重载的返回值必须写

4.2 赋值运算符重载

赋值运算符重载是对于两个已经存在对象之间的赋值拷贝。

简单写一下：

// d1 = d3
void operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;
}

这里可以完成功能，但是不符合连续赋值的含义 ，例如 i = j = k = 10 ，是将 10 赋给 k ，k 赋给 j ，j 赋给 i ，最后赋值后的返回值没有变量接收了，所以就把值丢弃，通过这种方式 完成连续赋值 。

但是此刻呢？


由于 operator= 没有返回值，这样就不可行了，所以需要修改 ：

// d1 = d3
Date operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;return *this;
}

根据上方的连续赋值规则，返回的应该是 左操作数 ，即 d1 ，也就是 this 指针指向的对象，即 *this ；但是对于 *this 的返回这里由于是传值返回，而 *this 指向的是一个对象，所以会调用拷贝构造函数：

class Date
{
public:Date(int year = 0, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date(const Date& d){cout << "进行拷贝构造" << endl;}// d1 = d3Date operator=(const Date& d){_year = d._year;_month = d._month;_day = d._day;return *this; // 调用拷贝构造}private:int _year;int _month;int _day;
};int main()
{Date d1(2023, 2, 3);Date d2(2023, 3, 4);Date d3(2022, 2, 3);d3 = d2 = d1; // 两次赋值，共计两次拷贝构造return 0;
}

*所以返回时，最好使用 引用返回 来提高返回效率，因为出作用域 this 仍然存在，所以引用返回完全没问题。

// d1 = d3
Date& operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;return *this;
}

此刻不进行拷贝构造：

但是此刻不是最终版本，因为可能会写错为 d1 = d1 ，自己给自己赋值 ，虽然代码并没有问题，但是浪费了赋值的过程，所以可以再加一个检查，形成最终版本 :

Date& operator=(const Date& d)
{if (this != &d) // this 和 d 的地址相等 {_year = d._year;_month = d._month;_day = d._day;}return *this;
}

总结一下赋值运算符重载格式 ：

• 参数类型：const T&，传递引用可以提高传参效率
• 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
• 检测是否自己给自己赋值
• 返回*this ：要符合连续赋值的含义
• 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝

编译器默认生成的赋值重载，跟拷贝构造做的事情完全类似 ：

• 内置类型成员，会完成字节序1值拷贝（浅拷贝）
• 自动类型成员，会调用它的 operator=

补充：

Date d2 = d1; // 拷贝构造 or 赋值重载？

两个已经存在的对象才是赋值重载，d5 并不存在，所以是拷贝构造：

学到这里，稍微总结一下 ：

以上默认生成的四个默认成员函数，析构和构造处理机制基本类似；拷贝构造和复制重载处理机制基本类似

5、const 成员

若定义了一个 const 的对象，然后访问其成员函数，会发生什么情况？

报错了，这是为什么？

因为在传参时，d2 的地址 &d2 会被传递给 Print() ，作为隐藏的参数 this 指针：

void Print(Date* const this) // this 指针隐藏
{cout << _year << '-' << _month << '-' << _day << endl;
}

对于Date d，传递过去的 &d 是 Date* ；而const Date d2，传递过去的 &d2 是 const Date* .

而对于 this 指针本身是 Date* const this ，此刻 const 修饰的是 this ，this 不可改，但是 *this 是可改的 ，而传参时传过来的 &d2 为 const Date* ，这时 const 修饰指针指向的内容，即对象本身不可改了。但是对于 this 来说，*this，也就是指向的内容，即对象本身是可改的，但是现在由于 const 使得指向内容不可改，权限被放大了。对于权限来说，只能对等和缩小，但是这里放大了，所以报错 。

为了解决这一问题，C++ 引入了 const 成员 ，在该成员后加上 const ：

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

void Print() const
{cout << _year << '-' << _month << '-' << _day << endl;
}

这时 this 指针的类型变为 const Date const this* ，权限对等了，这时 this 指针不能改，且 *this ，即 this 指向的对象也不能改，和 const Date d2 的目的相同：不可改 d2 . 这时，就没有问题了：

而对于 d 对象，它虽然没有 const ，但是也只是 权限缩小，使得 d 在 Print() 成员函数中不可修改而已，也是没问题的。

总结：成员函数加上 const 是好的，建议能加上 const 都加上。这样普通对象和 const 对象，都可以调用。但是如果对于要对 对象 进行修改的成员函数不要加上，这样就完成不了目的了。

注：对于构造和析构不能加上const修饰。

6、取地址与const取地址操作符重载

我们知道，对于自定义类型成员来说，平常的操作符需要重载后才能对对象进行操作。但是对于自定义类型的对象来说，如果不写这两个成员函数，使用默认的成员函数照样也可以完成目的：

所以我们一般不写，但是写的话也可以：

class A
{
public:A* operator&(){return this;}const A* operator&() const{return this;}
};

就只要返回 this 就可以；对于 const 取地址操作符，则要加上 const 成员，并且返回的指针也要加上 const 修饰。

总结

构造和析构：

• 内置类型不做处理
• 自定义类型会调用对应的构造/析构

拷贝构造和赋值运算符重载：

• 内置类型完成浅拷贝，按字节序拷贝
  *自定义类型去调用它的拷贝构造和赋值重载

取地址与const取地址操作符重载：

*可以直接取出成员的地址，一般不自己写