C++类和对象（类的默认成员函数）

目录

1.类的六个默认成员函数

2.构造函数 

2.1 概念

2.2 构造函数的特性

3.析构函数 

3.1 概念

3.2 特性

4.拷贝构造函数

4.1 概念

4.2 特征

5.赋值运算符重载

5.1运算符重载

 5.2        赋值运算符重载

7.取地址重载和const成员取地址重载

---

1.类的六个默认成员函数

一个没有任何内容的类简称空类。

那么空类真的就没有任何内容吗？任何类在什么都不写时，都会生成六个默认成员函数

什么是默认成员函数？即用户没有显式去写，编译器自动生成的默认成员函数。

class Date
{
    //空类真的什么都没有吗？
};

那是哪六个默认成员函数呢？

默认成员函数

构造函数	主要完成初始化
析构函数	主要完成清理
拷贝构造	使用同类对象初始化创建对象
赋值重载	将一个对象的值赋给另一个对象
普通对象取地址重载	默认返回this指针
const对象取地址重载	默认返回this指针

2.构造函数 

2.1 概念

假设有一个日期类如下：

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

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	d1.Init(2022, 9, 2);
}

对于Date类，可以调用Init公有方法完成日期的设置，每次创建对象都需要调用Init方法，显得过于繁琐，能不能在对象创建时就将信息写进去呢？

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

2.2 构造函数的特性

1.函数名和类名相同

2.没有返回值

3.对象创建时编译器自动调用对应的构造函数

4.构造函数可以重载

class Date
{
public:
	Date()//无参构造函数
	{}
	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(2022, 9, 1);//调用有参的构造函数
   //需要注意的是调用无参构造函数时，后面不用加括号，要不然就成了函数声明
    //下面一行代码表示：声明了一个d3函数，该函数无参，返回一个Date类型的对象
    Date d3();    
   // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
}

5.不显示定义构造函数  编译器会默认生成 一个无参的默认构造函数，一旦显示定义，编译器则不会默认生成。

class Date
{
public:
//放开以下注释编译器不会再默认生成构造函数，报错：error C2512: “Date”: 没有合适的默认构造函数可用
	//Date(int year,int month,int day)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
  
private:
	int _year;
	int _month;
	int _day;
};
	int main()
	{
		Date d1；//没有显示定义构造函数，编译器默认生成了一个无参的构造函数。
	}

 6.关于默认构造函数。

       编译器默认生成的构造函数，在d1对象创建后发现并没有对成员变量_year/_month/_day进行赋初值，它们还是随机值，这样看起来默认生成的构造函数好像没有什么用。

        其实是因为C++将类型分为内置类型（基础类型）和自定义类型。内置类型就是语言自身提供的数据类型：如char/int....这些；自定义类型就是我们自己去定义的类型：class/struct/union。运行下面的代码会发现：默认生成的构造函数，对于内置类型不做处理，对于自定义类型回去调用它的默认构造函数。

---

class Time
{
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
//没有显示定义构造函数，编译器默认生成
private:
	int _year;
	int _month;
	int _day;

	Time t;
};
	int main()
	{

		Date d3();
		return 0;
	}

 在C++11中，针对内置类型不处理的问题打了补丁，在成员变量声明处可以给默认值。        

class Time
{
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
//没有显示定义构造函数，编译器默认生成
private:
	int _year=1;
	int _month=1;
	int _day=1;

	Time t;
};
	int main()
	{

		Date d3();
		return 0;
	}

7.无参的构造函数和全缺省的构造函数都可以叫做默认构造函数，        默认构造函数只能有一个。

class Date
{
public:
	Date()//无参的默认构造函数
	{}
	Date(int year=1, int month=1, int day=1)//全缺省的默认构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}


private:
	int _year;
	int _month;
	int _day
};
int main()
{
    Date d1;//在创建对象时会调用哪一个构造函数呢？
}

在有两个默认构造函数时，创建对象d1调用哪一个都可以，就具有了歧义。

3.析构函数 

3.1 概念

我们知道了一个对像是如何初始化的，那一个对象又是如何销毁的呢？

析构函数：与构造函数的功能相反，不是完成对象本身的销毁，局部对象销毁工作由编译器完成。

而对象在销毁时会自动调用析构函数完成对象中资源的清理工作。

3.2 特性

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

1.析构函数是类名前加上~

2.无参数无返回类型

3.一个·类只能有一个析构函数，若没有显示定义，编译器就会默认生成一个析构函数。析构函数不能重载。

4.对象生命周期结束后，C++系统自动调用析构函数。

5.默认生成的析构函数对于内置类型不做处理，对于自定义类型会去调用它的析构函数。

6.如果对象内没有申请资源，析构函数可以不写，因为没有要释放的。但有申请资源的一定要写，如果不写，就会造成内存泄漏。

4.拷贝构造函数

4.1 概念

拷贝构造函数：只有一个形参，该形参是本类类型对象的引用，一般用const修饰，在用一个已存在的类类型对象创建新对象时回去调用。        

4.2 特征

拷贝构造函数：

1.是构造函数的一种重载形式。

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

3.如果没有显示定义拷贝构造函数，编译器会默认生成一个拷贝构造函数，对内置类型完成逐字节的拷贝，而自定义类型则去调用它的拷贝构造函数。        这种拷贝叫做值拷贝或者浅拷贝。

4.编译器默认生成的类以及可以完成字节序的值拷贝了，       那还有必要自己写一个吗？

没有涉及到申请资源的可以不写，但设计的申请资源的就必须要写了，否则就是浅拷贝。

5.构造函数调用场景

        ：使用已存在对象创建新对象

        ：函数参数为类类型对象

        ：函数返回值为类类型对象         

---

5.赋值运算符重载

5.1运算符重载

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

函数名：operator后面跟需要重载的运算符符号

函数原型 ：返回类型 operator操作符（参数列表）

注意：

        ：不能通过连接其他符号来创建新的操作符（如operator@）

        :   参数列表必须有一个参数是类类型对象

        :    当在类中定义为成员函数时，参数会比操作符的操作数少一个，因为第一个参数是this指针

        ：  用于内置类型的操作符，其含义不可被改变。

        ：  以下五个操作符不可被重载

.*        ::        ?:        sizeof        .

 5.2        赋值运算符重载

1.赋值运算符重载格式：

返回值类型：类类型对象引用--Date&,传引用返回可以提高效率

参数类型：const + 类类型对象的引用，传递引用提高效率

检查是否自己给自己赋值

返回*this:符合连续赋值的意义。

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

	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 d3;
		Date d2;
		d3 = d2;
		return 0;
	}

 2.赋值运算符只能重载成类的成员函数而不能是全局函数        

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

private:
	int _year;
	int _month;
	int _day;
};
	Date& operator=(const Date& d1，const Date& d2)//赋值运算符重载为全局的就会报错
	{                                     //因为编译器会在类里面再默认生成一个赋值运算符重载
		if (&d1 != &d2)
		{
			d1_year = d2._year;
			d1_month = d2._month;
			d1_day = d2._day;
		}
		return d1;
    }    
	int main()
	{
		Date d3;
		Date d2;
		d3 = d2;
		return 0;
	}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

3.不显示定义赋值运算符重载，编译器会默认生成一个，以值的方式逐字节拷贝。内置类型直接完成拷贝，自定义类型回去调用它的赋值运算符重载完成赋值

注意：像日期类这样的类不需要去写赋值重载，因为没有申请资源，一旦设计申请资源的类，赋值运算符重载则必须要实现。

6.const成员函数

将const修饰的成员函数称为const修饰的成员函数，const修饰成员函数，实际上是修饰成员函数隐含的this指针，表示该成员函数不可对类的任何成员进行修改。

7.取地址重载和const成员取地址重载

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

---

这篇博客就说到这里，如果其中有错漏或者不对的地方，欢迎斧正。