[c++ 简单的笔记] 类的6个默认成员函数

凶悍的狼

已于 2022-07-09 20:54:53 修改

阅读量419

点赞数 13

分类专栏： c++学习笔记文章标签： c++ 开发语言

于 2022-06-12 02:08:16 首次发布

本文链接：https://blog.csdn.net/weixin_51654781/article/details/125239769

版权

c++学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

-客亦知夫水与月乎?
-哀吾生之须臾羡长江之无穷.

文章目录

类的6个默认成员函数
构造函数
拷贝构造函数
- 务必自己写深拷贝的情况的情况
赋值运算符重载
析构函数
取地址及const取地址操作符重载

类的6个默认成员函数

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

如果我们不写,编译器就会自动生成下面6个默认成员函数,
如果我们写了某个成员函数,编译将不会生成对应的默认成员函数.

clas Date{}//创建一个空类,但同时会自动生成六个默认成员函数;

Date::Date()  //默认构造函数
Date::Date(const Date& a) //拷贝构造函数
Date::Data& operator=(const Data& d) //赋值运算符重载
Date::~Date() //析构函数
			
Date::Date* operator&() //对普通对象的取地址
 {
 return this ;
 }			
 
Date::const Date* operator&()const //对const对象的取地址
 {
 return this ;
 }


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

构造函数

特征:
1.函数名与类名相同且无返回值
2.对象构造(对象实例化)时系统自动调用对应的构造函数 并且在对象的生命周期内只调用一次
3.构造函数可以重载
4.如果类定义中没有给出构造函数,则c++编译会自动生成一个无参的构造函数,但只要我们定义了一个构造函数,系统就不会自动生成构造函数
5.无参数的构造函数和全缺省的构造函数都认为是默认构造函数,并且默认构造函数只能有一个
6.构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
7.系统默认生成的构造函数对其成员

如果是内置类型不处理,即内置类型的值是随机值.

而对自定义类型将会调用该类型的默认构造函数,如果自定义类型没有默认构造函数,那么就会报错.

构造函数初始化列表

构造函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

class Data
{
public:
	//这里不能倍称为初始化，只能叫赋值
	Data (int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。例如

class A
{
 public:
	A(int a)
	  :_a(a){
	 
	}
 private:
	int _a;
	
};
class B
{
 public:
	 B(int a, int ref)
	   :_aobj(a)
 	   ,_ref(ref)
 	   ,_n(10)
 {}
 private:
	A _aobj; // 没有默认构造函数
	int& _ref; // 引用
	const int _n; // const 
};

注意

1.每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2.类中包含以下成员，必须放在初始化列表位置进行初始化：

        const 成员或引用类型的成员 因为 const 对象或引用类型只能初始化，不能对他们赋值。

        自定义类型成员(该类没有默认构造函数)



        所以尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
3.初始化列表的成员初始化顺序:
        C++ 初始化类成员时，是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。

explicit关键字(了解)

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。

class Date
{
public:
 Date(int year)
 :_year(year)
 {}
 
 explicit Date(int year)
 :_year(year)
 {}
 
private:
 int _year;
 int _month:
 int _day;
}；
void TestDate()
{
 Date d1(2018);
 
 // 用一个整形变量给日期类型对象赋值
 // 实际编译器背后会用2019构造一个无名对象，最后用无名对象给d1对象进行赋值
 d1 = 2019;
}


上述代码可读性不是很好，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。

拷贝构造函数

特征：

拷贝构造函数其实是一个构造函数的重载
拷贝构造函数的参数必须使用引用传参，使用传值方式会引发无穷递归调用。
如果没有显示定义拷贝构造函数的话，系统会生成默认的拷贝构造函数 默认的拷贝构造函数按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝
类中存在资源管理时就务必自己写深拷贝,拷贝构造函数务必自己实现,或者容易引发诸多问题,例如对象的生命周期结束的时候,调用析构函数时,将会多次free同一个地址,而导致程序崩溃.

class Date
{
public:
	Date(int year = 1900, 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;
}

务必自己写深拷贝的情况的情况

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
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;
};

int main()
{
	String s1("hello");
	String s2(s1);
	return 0;
}

赋值运算符重载

特征(每一点都很重要)

参数类型 (参数也是该类型的引用，并且因为不会改变内容，最好加const修饰)
返回值 (为了符合运算符重载的要求，同时为了支持连续赋值，所以返回值必须是该类型的引用)
检测是否自己给自己赋值(判断有没有给自己赋值的重要性)
返回*this (为了支持连续赋值)
一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

class Data
{
public:
/*
		....
*/
	Data& operator=(const Data& 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(2021,5,6);  ///调用构造函数
	Date d2(2024,6,9);	//调用构造函数
	
	d2 = d1;		//调用 赋值运算符重载

	//特别注意:
	Date d3 = d2; //调用 拷贝构造    
}

析构函数

析构函数(destructor) 与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。

特征:

析构函数名是在类名前加上字符 ~。
无参数无返回值。
一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
析构函数不能重载
编译器生成的默认析构函数，对自定义类型成员会调用它的析构函数,而对内置成员不做处理(下面的代码你就能看到)
对象生命周期结束时，C++编译系统系统自动调用析构函数

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;
}