类的六个默认成员函数

最新推荐文章于 2023-09-15 22:30:00 发布

起个名字好难丫

最新推荐文章于 2023-09-15 22:30:00 发布

阅读量547

点赞数 1

分类专栏： C++ 文章标签：六大成员函数构造函数析构函数拷贝构造运算符重载

本文链接：https://blog.csdn.net/weixin_42307601/article/details/102771224

版权

C++ 专栏收录该内容

44 篇文章 0 订阅

订阅专栏

类的六个默认成员函数

写在前面：
如果我们定义一个空类如下：

class name
{
};

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

初始化和清理
构造函数完成初始化工作，析构函数完成一些资源的清理工作
拷贝复制
拷贝构造是完成同类对象初始化创建对象，赋值重载主要把赋值对象给另一个对象
取地址重载
主要是取地址和const对象取地址，这两个很少自己实现。

我们具体再来说一下吧！

1、构造函数（主要完成初始化）

先来看一下我们一般是如何初始化的。

#include<iostream>
#include<stdlib.h>
using namespace std;
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,d2;
	d1.Init(2019,10,27);
	d1.Print();
	d2.Init(2021,6,8);
	d2.Print();
	system("pause");
	return 0;
}

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

因此引入构造函数的概念

1.定义：

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

2.特性：

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

特征：

函数名与类名相同。
无返回值。
对象实例化时编译器自动调用对应的构造函数。
构造函数可以重载

class Date
{
public:
	Date()//无参构造函数，初始化时给的是随机值
	{}
	Date(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;//注意是分号结尾，不然就成了声明一个返回值为Date类的无参函数
	d1.Print();
	Date d2(2019,2,3);//调用带参构造函数
	d2.Print();
	system("pause");
	return 0;
}

这是我们实现的构造函数，那当我们没有定义构造函数时会怎么样呢？

class Date
{
public:
	//Date(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.Print();
	system("pause");
	return 0;
}

在这里插入图片描述
这里我们可以看到，并没有构造函数，而我们还是可以成功定义 d1 并完成随机值的初始化，这是为什么呢？

没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数

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

class Date
{
public:
	Date()//定义两个默认构造函数
	{
       year=2018;
	   month=3;
	   day=6;
	}
	Date(int _year=2109,int _month=5,int _day=5)//带参构造函数
	{
		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.Print();
	//Date d2(2018,5,6);
	//d2.Print();
	system("pause");
	return 0;
}

在这里插入图片描述
可以看到这里报了一个错和一个警告，第一个是两个函数构成重载，但函数调用不明确，不能达到初始化的效果，且报了一个警告，显示指定多个默认构造函数，因此建议大家，尽量定义一个。但是大家还是觉得构造函数没什么用处，别着急，以后深入学习之后，你就会对它有更深刻的理解。

2、析构函数（完成清理工作）

1.定义：

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

2.特征：

析构函数是特殊的成员函数。
其特征如下：

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

来看一段代码，看他是否会调用析构函数。

class String
{
public:
	String(const char* _str="xiaoming")
	{
		str=(char*)malloc(strlen(_str)+1);
		strcpy(str,_str);
		cout<<"String"<<endl;
	}
	~String()
	{
		cout<<"~String()"<<endl;
		free(str);
	}
private:
	char *str;
};
class Student
{
public:
	//String b;
};
int main()
{
	String c;
	//a.b.~String();
	system("pause");
	return 0;
}

这里的结果应该是：
在这里插入图片描述
可以看到，调用了我们定义的构造和析构函数。
（在这里发生了一个小插曲，在我的vs2012无论如何都不调用我定义的析构函数，后来在朋友vs2013上显示调用了，建议大家还是尽量不要用vs2012的吧，版本问题很难受）

3、拷贝构造函数

1.定义：

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

拷贝构造函数也是特殊的成员函数，其特征如下：

拷贝构造函数是构造函数的一个重载形式。
拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用

#include<iostream>
#include<stdlib.h>
using namespace std;
class Date
{
public:
	Date(int _year=1900,int _month=6,int _day=8)
	{
		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;
	}
private:
	int year;
	int month;
	int day;
};
int main()
{
	Date d1;
	Date d2(d1);
	d1.Print();
	d2.Print();
	system("pause");
	return 0;
}

看一下结果：
在这里插入图片描述
可以看到，我们就好像给d1造了一双胞胎一样，是因为本质上，拷贝构造与构造函数构成重载。

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

class Date
{
public:
	Date(int _year=1900,int _month=6,int _day=8)
	{
		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(d1);
	Date d3(d2);
	d1.Print();
	d2.Print();
	d3.Print();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述
可以看到编译器是会自动生成一个默认拷贝构造函数的。

现在只是简单的值拷贝，以后会讲到深拷贝。

4.赋值运算符重载

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

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

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

具体来看一个重载**" == "** 来判断两个时间是否相同的功能实现：

#include<iostream>
#include<stdlib.h>
using namespace std;
class Date
{
public:
	Date(int _year,int _month,int _day)
	{
		year=_year;
		month=_month;
		day=_day;
	}
	~Date()
	{
		year=0;
		month=0;
		day=0;
	}
//private://这里定义成public是因为需要访问，成员变量，那就失去了封装性，这个在以后的友元函数再做介绍
	int year;
	int month;
	int day;
};
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(2019,2,3);
	Date d2(2019,2,3);
	Date d3(2019,4,5);
	Date d4(2018,5,4);
	cout<<(d1==d2)<<endl;
	cout<<(d3==d4)<<endl;
}
int main()
{
	Test();
	system("pause");
	return 0;
}

看一下结果：
在这里插入图片描述
可以看到，当时间相同时返回1，不同时返回 0。

通过上面的代码，我们就简单的实现了，操作符 " == " 的重载。这是我们定义的全局的operator 也可以定义在类里面作为成员函数。

class Date
{
public:
	Date(int _year=1900,int _month=1,int _day=1)
	{
		year=_year;
		month=_month;
		day=_day;
	}
	bool operator==(const Date& d2)//这里有一个默认的形参Date *this
{   //因此不用写const Date& d1,否则会显示调用参数过多
	return year==d2.year
		&&month==d2.month
		&&day==d2.day;
}
//private:
	int year;
	int month;
	int day;
};
void Test()
{
	Date d1(2019,3,4);
	Date d2(2019,3,4);
	cout<<(d1==d2)<<endl;
}
int main()
{
	Test();
	system("pause");
	return 0;
}

在这里插入图片描述

5、6取地址及const取地址操作符重载

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

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&() const
	{
		return this;
	}
private:
	int year;
	int month;
	int day;
};
int main()
{
	Date d;
	cout<<&d<<endl;
	cout<<&d<<endl;
	system("pause");
	return 0;
}

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

另外再讲一下const

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

看一个例子：

class Date
{
public:
	void  Init(int _year,int _month,int _day) //const
	{
		year=_year;
		month=_month;
		day=_day;
	}
	void Print() const
	{
		cout<<year<<" "<<month<<" "<<day<<endl;
	}
private:
	int year;
	int month;
	int day;
};
int main()
{
	//const Date d;
	//d.Init(2019,2,3);
    //d.Print();
	Date d1;
	d1.Init(2019,2,3);
    d1.Print();
	system("pause");
	return 0;
}

在这里插入图片描述

可以看到当我们要修改某个值时，不能用const来修饰函数，而只读的话，是允许的，而当const 访问const时也是可以的。

总结为下：

const对象调用const对象没问题
普通对象调用普通对象也没问题
但const不能调用普通对象（非const对象），而普通对象可以调用const对象。
简单理解起来就是：权限不能被放大。（例如，我是只读，你可以读，但是你不能修改我）

起个名字好难丫

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
类的六个默认成员函数

本片文章主要介绍：类的六大默认成员函数，在函数未定义时会自动默认生成，而常用的有四个分别是：完成初始化（不是创建对象）的构造函数，完成一些资源清理的析构函数，还有拷贝构造函数，拷贝构造可以看做是构造函数的重载，而赋值重载，吧对象赋值给另一个对象，还有运算符重载、const 等。
复制链接

扫一扫