C++ 类与对象(中)

爱被打了一巴掌 2024-04-18 14:36 61阅读 0赞

**目录**

###        [C++类与对象(上)][C] ###

类的6个默认成员函数

一.构造函数

二.析构函数

三.拷贝构造函数

四.赋值运算符重载

五,六.取地址及const取地址操作符重载

### [C++ 类与对象(下)][C_] ###

--------------------

## 类的6个默认成员函数 ##

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

--------------------

## 一.构造函数  ##

> 构造函数是一个特殊的成员函数，名字与类名相同 , 且不会返回任何类型，也不会返回 void , 创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次 .
> 
> 需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

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

#include<iostream>
    using namespace std;
    class Date {
    	int m_year;
    	size_t m_month;
    	size_t m_day;
    public:
    	Date() {
    
    	}
    	Date(int y, size_t m, size_t d) {
    		m_year = y;
    		m_month = m;
    		m_day = d;
    	}
    	void SetDate(int y, size_t m, size_t d);
    	void PrintDate();
    };
    void Date::PrintDate() {
    	cout << m_year << "年" << m_month << "月" << m_day << "日\n";
    }
    void Date::SetDate(int y, size_t m, size_t d) {
    	m_year = y;
    	m_month = m;
    	m_day = d;
    }
    int main() {
    	Date a;//调用无参构造
    	Date b(2019, 10, 1);//调用有参构造
    	a.SetDate(2020, 12, 1);
    	a.PrintDate();
    	b.PrintDate();
    	system("pause");
    	return 0;
    }

![20190908103551870.png][]

注意 : 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再     生成, 如上代码定义了一个啥也没干的无参构造 , 编译器就不会自动生成无参的默认构造

**5.** 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且**默认构造函数只能有一个**。注意：无参构造函数、全缺省构造函数、编译器默认生成的构造函数，都可以认为是默认成员函数。来看一下代码

#include<iostream>
    using namespace std;
    class Date {
    	int m_year;
    	size_t m_month;
    	size_t m_day;
    public:
    	Date() {
    
    	}
    	Date(int y = 2019, size_t m = 10, size_t d = 1) {
    		m_year = y;
    		m_month = m;
    		m_day = d;
    	}
    };
    int main() {
    	Date a;
    	Date b(2019, 1, 1);
    	return 0;
    }

上面的代码在编译时发生了错误, 错误指向 Date a , 错误如下 :   
![20190908104430216.png][]

因为在创建对象a时 , 由于没有传参, 编译器可以调用全缺省参数的构造函数, 也可以调用无参的构造函数 , 调用构造函数时出现了二义性 , 所以编译器懵了

![20190908152408426.png][]                     ![201909081052471.png][]

**7 .** 带参构造函数的定义

> **1.  狭义初始化,初始化列表**
> 
>    成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
> 
>    如const 变量, 引用 , 类 类型成员(该类没有默认构造函数), 这三种成员变量不能在构造函数内赋值, 只能用狭义初始化
> 
>    还有在类的继承时, 子类构造函数在调用父类(基类)的构造函数只能在初始化列表中调用.
> 
>     class A{
>         int a;
>     public:
>         A : a(0)
>         { }
>     };
> 
>   
> **2.广义初始化**
> 
>     class A{
>         int a;
>     public:
>         A (int t){
>             a = t;
>         }
>     };
> 
>

**8.** 成员变量的命名风格

> 我们来看一小段代码
> 
>     class Date {
>         int year;
>         int m_year;
>     public:
>         Date(int year) {
>             m_year = year;
>             // 这里的year到底是成员变量，还是函数形参？
>             year = year;
>         }
>     };

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70][]

VS2017会把两个year都当成形参

![20190908111332892.png][]            ![20190908111108806.png][]        ![20190908111323619.png][]

所以为了避免这种问题的出现, 我们可以在类的成员前后加标识符, 如上面代码中的m\_year, 很多公司的代码规范中都会有这样的要求 .

--------------------

## 二.析构函数 ##

> 在创建对象时需要调用构造函数来初始化一下这个对象, 一个对象在诞生的时候需要有构造函数, 那么它 "没" 的时候呢?
> 
> ![20190908143751563.png][]
> 
>  
> 
>    ...其实类还是有始有终的, 对象在释放时会调用析构函数, 完成类的一些资源清理工作

> **析构函数**：析构函数也是一种特殊的成员函数 , 它执行与构造函数相反的操作 , 通常用于执行一些清理任务,  对象在销毁时会自动调用析构函数, 完成类的一些资源清理 (析构并不会执行释放对象内存的操作)

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

#include<iostream>
    using namespace std;
    class Date {
    	int m_year;
    	size_t m_month;
    	size_t m_day;
    public:
    	Date(int y = 2019, size_t m = 10, size_t d = 1) {
    		m_year = y;
    		m_month = m;
    		m_day = d;
    	}
    	~Date() {
    		PrintDate();
    		cout << "调用析构函数\n";
    	}
    	void PrintDate();
    };
    void Date::PrintDate() {
    	cout << m_year << "年" << m_month << "月" << m_day << "日 ";
    }
    void Test() {
    	Date a;
    	Date b(2019, 1, 1);
    }
    int main() {
    	Test();
    	system("pause");
    	return 0;
    }

![20190908145538216.png][]

**5.** 关于编译器自动生成的析构函数，是否也会完成同样的事呢？来看下面的代码  
*.cpp*

#include<iostream>
    using namespace std;
    class Student {
    	int m_age;
    public:
    	Student() {
    
    	}
    	~Student() {
    		cout << "调用~Student()" << endl;
    	}
    };
    class Person {
    	char* m_name;
    	Student m_age;
    	char* m_sex;
    };
    void test() {
    	Person p;
    }
    int main() {
    	test();
    	system("pause");
    	return 0;
    }

![20190908150605899.png][]

我们可以看到编译器自己生成的默认析构函数会调用类类型成员的析构函数。

--------------------

## 三.拷贝构造函数 ##

![201909081623539.png][]            ![2019090816171268.png][]

人们之间可以传递 , 分享快乐 , 熊猫头还可以创建一份一模一样的快乐 , 那么在创建对象时业能否创建一个一模一样的呢?  
答案是肯定的, 我们可以通过拷贝构造函数来实现

> **拷贝构造函数:** 特殊的构造函数(构造函数的重载) , 只有单个形参(不算隐藏的this指针)，该形参是对本类类型对象的引用(一般常用const修饰)，在建立一个新对象时, 使用一个已经存在的对象去初始化这个新对象, 例如: 对象d1已存在
> 
>     Date d2(d1);
> 
> 或者
> 
>     Date d2 = d1;
> 
> 注意不能是Date d2;  d2 = d1; 这样调用的是赋值运算符重载函数

拷贝构造函数也是特殊的成员函数，其**特征**如下：  
**1.** 拷贝构造函数是构造函数的一个重载形式(所以函数名也与类名相同, 无返回值)。  
**2.** 拷贝构造函数的**参数只有一个且必须使用引用传参**，使用传值方式会引发无穷递归调用。  
    因为当形参是对象时, 我们知道当一个(有参)函数被调用会发生实参给形参传值的情况, 拷贝构造函数也一样, 这就尴尬了, 形参是对象 , 实参也是对象 ,一传参就又要调用拷贝构造函数 , 再次调用又会出现这种情况, 无穷无尽递归调用 .我们传引用就可以很好地解决这个问题, 既让拷贝构造函数得到了已存在对象的数据给新对象赋值 , 又不会出现自递归  
注意 : 函数传参是在定义形参变量时给参数赋初值的, 相当于int a = 1这种形式, 所以调用的是拷贝构造而不是赋值运算符重载(下面会说什么是赋值运算符重载)  
**3. **若未显式定义，系统会生成默认的拷贝构造函数。 **默认的拷贝构造函数对象按内存存储按字节序完成拷贝**，这种拷贝我 们叫做浅拷贝，或者值拷贝。当然, 有了浅拷贝肯定会有深拷贝, 我们先来看浅拷贝  
*    .cpp*

#include<iostream>
    using namespace std;
    class Date {
    	int m_year;
    	size_t m_month;
    	size_t m_day;
    public:
    	Date(int y, size_t m, size_t d) {
    		m_year = y;
    		m_month = m;
    		m_day = d;
    	}
    	void PrintDate();
    };
    void Date::PrintDate() {
    	cout << m_year << "年" << m_month << "月" << m_day << "日\n";
    }
    int main() {
    	Date a(2019, 10, 1);
    	Date b(a);
    	a.PrintDate();
    	b.PrintDate();
    	system("pause");
    	return 0;
    }

![20190908170436222.png][]

我们可以看到b的值和a一样, b调用默认拷贝构造函数时执行的是浅拷贝, 这样看来有了浅拷贝不就完事了吗, 然鹅, 事情并不是这么简单的, 我们再来看浅拷贝解决不了的问题  
*.cpp*

#include<iostream>
    using namespace std;
    class Test {
    	size_t m_size;
    	int* m_arr;
    public:
    	Test(size_t size) {
    		m_size = size;
    		m_arr = (int*)malloc(sizeof(int)*size);
    	}
    	~Test() {
    		//free(m_arr);//这句会在程序结束后发生错误
    		//原因是两个对象析构时会free()同一片内存空间
    	}
    	void SetTest();
    	void PrintTest();
    };
    void Test::SetTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << "请输入第" << i + 1 << "个元素的值\n";
    		cin >> m_arr[i];
    	}
    }
    void Test::PrintTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << m_arr[i] << "  ";
    	}
    	cout << endl;
    }
    void test() {
    	Test a(3);
    	cout << "给对象a输入数据\n";
    	a.SetTest();
    	Test b(a);
    	cout << "打印对象a:\n";
    	a.PrintTest();
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "给对象b输入数据\n";
    	b.SetTest();
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "打印对象a:\n";
    	a.PrintTest();
    }
    int main() {
    	test();
    	system("pause");
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1][]  
我们可以看到 , 在修改了对象b的值之后, 对象a的值也发生了变化, 这是为什么呢?  
因为默认的拷贝构造函数执行的是浅拷贝, 只拷贝变量的值, 在创建对象a时 , 在堆上开辟了12 (3\*sizeof(int)) 个字节的空间, 将这片空间的首地址给了对象a的成员m\_arr, 此时再创建对象b, b调用默认的拷贝构造函数执行浅拷贝, 会将a.m\_arr的值给b.m\_arr, 这就出现了问题 , 这两个对象a,b中的a. m\_arr, b.m\_arr都指向了对象a中在堆上开辟的那片空间, 也就是说, 创建对象b时并没有单独开辟空间 . 并且析构函数也会出现问题, 如果我们在析构函数中free(m\_arr)的话, a,b两个个对象在程序结束前都会调用析构, 会出现干重复释放同一片内存的问题 , 此时free()会出错, 以上这些情况显然是我们不愿意看见的, 浅拷贝解决不了, 那就只能深拷贝  
**深拷贝** : 在进行赋值之前，为指针类型的数据成员另辟了一个独立的内存空间，实现真正内容上的拷贝, 显然默认的拷贝构造函数实现不来这种操作 . 这种深拷贝的拷贝构造函数需要我们自己实现 , 来看下面代码  
                                               ![20190908175835808.png][]

*.cpp*

#include<iostream>
    using namespace std;
    class Test {
    	size_t m_size;
    	int* m_arr;
    public:
    	Test(size_t size) {
    		m_size = size;
    		m_arr = (int*)malloc(sizeof(int)*size);
    	}
    	Test(Test& t) {
    		m_size = t.m_size;
    		m_arr = (int*)malloc(sizeof(int)*m_size);
    		for (int i = 0; i < (int)m_size; ++i) {
    			m_arr[i] = t.m_arr[i];
    		}
    	}
    	~Test() {
                if (m_arr) {
    		free(m_arr);
    	    }
    	    cout << "释放首地址为" << m_arr << "的这片内存空间\n";
    	    m_arr = nullptr;
    	}
    	void SetTest();
    	void PrintTest();
    };
    void Test::SetTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << "请输入第" << i + 1 << "个元素的值\n";
    		cin >> m_arr[i];
    	}
    }
    void Test::PrintTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << m_arr[i] << "  ";
    	}
    	cout << endl;
    }
    void test() {
    	Test a(3);
    	cout << "给对象a输入数据\n";
    	a.SetTest();
    	Test b(a);
    	cout << "打印对象a:\n";
    	a.PrintTest();
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "给对象b输入数据\n";
    	b.SetTest();
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "打印对象a:\n";
    	a.PrintTest();
    }
    int main() {
    	test();
    	system("pause");
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2][]

我们可以看到修改对象b的值, 对象a的值不会像上面的浅拷贝一样也会被修改, 并且两次释放的内存空间不是同一片, 自购函数中free()也不会出错 .

--------------------

## 四.赋值运算符重载 ##

**运算符重载**

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

**注意：**  
**1.** 不能通过连接其他符号来创建新的操作符：比如operator@  
**2.** 重载操作符至少有一个自定义类型(struct ,class , enum), 也就是说, 运算符重载函数的参数不能全部都是C++标准类型  
    如: int operate\+(int x, int y);是错误的, 为了防止用户修改运算符的性质 .  
*   .cpp文件*

#include<iostream>
    using namespace std;
    struct Date {
    	int m_year;
    	int m_month;
    	int m_day;
    };
    bool operator==(const Date& d1, const Date& d2){
    	return d1.m_year == d2.m_year&& d1.m_month == d2.m_month&& d1.m_day == d2.m_day;
    }
    void Test() {
    	Date d1 = { 1,2,3 };
    	Date d2 = { 1,2,3 };
    	Date d3 = { 0,2,3 };
    	cout << "d1与d2 ";
    	(d1 == d2) ? cout << "相等\n" : cout << "不相等\n";
    	cout << "d1与d3 ";
    	(d1 == d3) ? cout << "相等\n" : cout << "不相等\n";
    }
    int main() {
    	Test();
    	system("pause");
    	return 0;
    }

![20190908213332357.png][]

其中 operator == (const Date& d1, const Date& d2) ; 是一个普通的全局函数 , 能访问结构体内成员是因为C++中结构体  
    成员默认公有 . C++面对对象的特性之一就是封装, 那C++中类中数据(成员变量)一般都是私有的, 全局的operator==函数显然        就有些不适用了, 这时我们可以将其定义成友元函数或者直接重载成类的成员函数  
**3.** 只能重载系统预定义的运算符，其含义不能改变，运算符的优先级, 结合性, 操作数个数都不能改变  
**4.**  注意只有5个运算符不能重载。这个经常在笔试选择题中出现。  
     "  **.****\*** "            成员指针访问运算符  
     " **::** "             作用域限定符符  
     " **sizeof**  "    长度运算符  
     " **?** : "           条件运算符  
     " **.** "              成员访问运算符  
**5.** 运算符重载函数可以是**普通函数**, 也可以是**类的成员函数**, 还可以是**类的友元函数  
6.** 一般而言,用于类对象运算的运算符必须重载, 但赋值运算符" = "是个例外(也不全是例外, 接下来我们细说), 不必进行重载.

**赋值运算符重载**  
*.cpp*

#include<iostream>
    using namespace std;
    class Date {
    	int m_year;
    	int m_month;
    	int m_day;
    public:
    	Date(int year = 2019, int month = 10, int day = 1) {
    		cout << "调用Date()\n";
    		m_year = year;
    		m_month = month;
    		m_day = day;
    	}
    	Date(const Date& d) {
    		cout << "调用拷贝Date()\n";
    		m_year = d.m_year;
    		m_month = d.m_month;
    		m_day = d.m_day;
    	}
    	Date& operator=(const Date& d) {
    		cout << "调用operator=()\n";
    		if (this != &d) {
    			m_year = d.m_year;
    			m_month = d.m_month;
    			m_day = d.m_day;
    		}
    		return *this;
    	}
    };
    void Test(){
    	Date d1(2019, 9, 27);
    	Date d2 = d1;
    	Date d3;
    	d3 = d1;
    }
    int main() {
    	Test();
    	system("pause");
    	return 0;
    }

![20190908220447604.png][]

值得注意的是Date d2 = d1; 与 Date d3; d3 = d1; 前者调用的是拷贝构造函数, 后者调用的是赋值运算符重载函数  
赋值运算符主要有四点：  
1. 参数类型(自定义类型或者自定义类型的引用)  
2. 返回值(\*this, 返回本对象的引用)  
3. 检测是否自己给自己赋值(这是为了效率, 不影响正确性)  
5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝(浅拷贝)  
    又是浅拷贝, 前面说的" 类对象运算的运算符必须重载, 但赋值运算符" = "是个例外(也不全是例外) ", 这个" 也不全是例外 "的原      因就在这, 我们来看这段代码  
*.cpp*

#include<iostream>
    using namespace std;
    class Test {
    	size_t m_size;
    	int* m_arr;
    public:
    	Test(size_t size = 0) {
    		m_size = size;
    		m_arr = (int*)malloc(sizeof(int)*size);
    	}
    	~Test() {
    		/*if (m_arr) {
    			free(m_arr);
    		}*/
    	}
    	//Test& operator=(const Test& t);
    	void SetTest();
    	void PrintTest();
    };
    //Test& Test::operator=(const Test& t) {
    //	m_size = t.m_size;
    //	m_arr = (int*)malloc(sizeof(int)*m_size);
    //	for (int i = 0; i < (int)m_size; ++i) {
    //		m_arr[i] = t.m_arr[i];
    //	}
    //	return *this;
    //}
    void Test::SetTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << "请输入第" << i + 1 << "个元素的值\n";
    		cin >> m_arr[i];
    	}
    }
    void Test::PrintTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << m_arr[i] << "  ";
    	}
    	cout << endl;
    }
    void test() {
    	Test a(3);
    	Test b;
    	cout << "给对象a输入数据\n";
    	a.SetTest();
    	cout << "打印对象a:\n";
    	a.PrintTest();
    	b = a;
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "给对象b输入数据\n";
    	b.SetTest();
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "打印对象a:\n";
    	a.PrintTest();
    }
    int main() {
    	test();
    	system("pause");
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 3][]

出现了和上面调用默认拷贝构造函数时相同的问题, 原因也一样, 就不多说, 解决方式也一样, 我们自己写一个就完了, 如下:  
*.cpp*

#include<iostream>
    using namespace std;
    class Test {
    	size_t m_size;
    	int* m_arr;
    public:
    	Test(size_t size = 0) {
    		m_size = size;
    		m_arr = (int*)malloc(sizeof(int)*size);
    	}
    	~Test() {
    		if (m_arr) {
    			free(m_arr);
    		}
    	}
    	Test& operator=(const Test& t);
    	void SetTest();
    	void PrintTest();
    };
    Test& Test::operator=(const Test& t) {
    	m_size = t.m_size;
    	m_arr = (int*)malloc(sizeof(int)*m_size);
    	for (int i = 0; i < (int)m_size; ++i) {
    		m_arr[i] = t.m_arr[i];
    	}
    	return *this;
    }
    void Test::SetTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << "请输入第" << i + 1 << "个元素的值\n";
    		cin >> m_arr[i];
    	}
    }
    void Test::PrintTest() {
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << m_arr[i] << "  ";
    	}
    	cout << endl;
    }
    void test() {
    	Test a(3);
    	Test b;
    	cout << "给对象a输入数据\n";
    	a.SetTest();
    	cout << "打印对象a:\n";
    	a.PrintTest();
    	b = a;
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "给对象b输入数据\n";
    	b.SetTest();
    	cout << "打印对象b:\n";
    	b.PrintTest();
    	cout << "打印对象a:\n";
    	a.PrintTest();
    }
    int main() {
    	test();
    	system("pause");
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 4][]

我们可以看到结果正常了

--------------------

## **五,六.取地址及const取地址操作符重载** ##

**const修饰类的成员函数**

> 将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对调用它对象的任何成员进行修改。  
> 函数原型 : 返回值类型 函数名(参数列表) const;

我们来看编译器对const函数的处理

void Test::PrintTest() const { 
    	for (int i = 0; i < (int)m_size; ++i) {
    		cout << m_arr[i] << "  ";
    	}
    	cout << endl;
    }

编译器会处理成为

void Test::PrintTest(const Test* this) { 
    	for (int i = 0; i < (int)this->m_size; ++i) {
    		cout << this->m_arr[i] << "  ";
    	}
    	cout << endl;
    }

我们来看下面这段代码  
*.cpp*

#include<iostream>
    using namespace std;
    class Date {
    	int m_year;
    	size_t m_month;
    	size_t m_day;
    public:
    	Date(int y, size_t m, size_t d) {
    		m_year = y;
    		m_month = m;
    		m_day = d;
    	}
    	void PrintDate();
    	void PrintDate()const;
    };
    void Date::PrintDate() {
    	cout << "调用PrintDate()\n";
    	cout << m_year << "年" << m_month << "月" << m_day << "日\n";
    }
    void Date::PrintDate() const{
    	cout << "调用PrintDate()const\n";
    	cout << m_year << "年" << m_month << "月" << m_day << "日\n";
    }
    int main() {
    	Date a(2019, 10, 1);
    	const Date b(2019, 10, 2);
    	a.PrintDate();
    	b.PrintDate();
    	system("pause");
    	return 0;
    }

![20190909003849801.png][]

问题

1. const对象可以调用非const成员函数吗？  
    不可以, 因为const 类型对象的指针为 const类类型\*  强转不成非const类型的的 类类型\*  
2. 非const对象可以调用const成员函数吗？  
    可以, 因为非const 类型对象的指针为 类类型\*  可以转换成 const 类类型\*  
3. const成员函数内可以调用其它的非const成员函数吗？  
    不可以, 同样,因为const 类型对象的指针为 const类类型\*  强转不成非const类型的的 类类型\*  
4. 非const成员函数内可以调用其它的const成员函数吗？  
    可以, 因为非const 类型对象的指针为 类类型\*  可以转换成 const 类类型\*

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

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

如下代码:  
*.cpp*

#include<iostream>
    using namespace std;
    class Date {
    	int m_year;
    	size_t m_month;
    	size_t m_day;
    public:
    	Date() {
    
    	}
    	Date* operator& () {
    		cout << "Date* operator& ()被调用\n";
    		return this;
    	}
    	const Date* operator& () const { 
    		cout << "const Date* operator& () const 被调用\n";
    		return this;
    	}
    };
    
    int main() {
    	Date a;
    	&a;
    	const Date b;
    	&b;
    	system("pause");
    	return 0;
    }

![20190909010105545.png][]

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

[C]: https://blog.csdn.net/qq_41071068/article/details/100605703
[C_]: https://blog.csdn.net/qq_41071068/article/details/100666369
[format_png]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy50aW5neXVjYW5oZS5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMTgvMTIvNiVFNCVCOCVBQSVFOSVCQiU5OCVFOCVBRSVBNCVFNiU4OCU5MCVFNSU5MSU5OCVFNSU4NyVCRCVFNiU5NSVCMC5wbmc?x-oss-process=image/format,png
[20190908103551870.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/010f391e34344e78bb8b8097de8c1861.png
[20190908104430216.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d48cbd6dd172414890ab7fd80ca307a1.png
[20190908152408426.png]: https://img-blog.csdnimg.cn/20190908152408426.png
[201909081052471.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2e7a520381234505bca1a60690ea0518.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f3c3e1b366504dfdbed4a708195cf069.png
[20190908111332892.png]: https://img-blog.csdnimg.cn/20190908111332892.png
[20190908111108806.png]: https://img-blog.csdnimg.cn/20190908111108806.png
[20190908111323619.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/50ef0b5fca1649e1989df90640594550.png
[20190908143751563.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/fc711d4a005d4af0b258d6bd9dd27e33.png
[20190908145538216.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/445b82086a7c4c89829bc1560d6d85d6.png
[20190908150605899.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d4e4270a54854c2696bab608c70b6678.png
[201909081623539.png]: https://img-blog.csdnimg.cn/201909081623539.png
[2019090816171268.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d46d5a484ac348fc83dfa081bd0373f5.png
[20190908170436222.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f78e2cf90aef4035a051fe44d7c27d7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5776ea7729dd45e98b4de48df3a5790d.png
[20190908175835808.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/78cf1cc1474e4909959cfecef8713292.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/c53c154f7a6747168cba30b5a824874f.png
[20190908213332357.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8222c74816e441a89edeac20441f4871.png
[20190908220447604.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2b8bb1d981a44df19e282d4a0fa42284.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/963d287b75614680a858aebcb5e4f353.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2a25d2dab19d4d1289d5973f0ac82bb0.png
[20190909003849801.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8a3d0fa3a7084332834cced3a1db7b82.png
[20190909010105545.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ce7223924a224eddad1fccdbdcaa2126.png