C++类与对象—默认成员函数

最新推荐文章于 2022-11-01 18:23:45 发布

ice_玖闻于世丶

最新推荐文章于 2022-11-01 18:23:45 发布

阅读量176

点赞数

分类专栏： C++面向对象编程

本文链接：https://blog.csdn.net/weixin_42357849/article/details/103088182

版权

C++面向对象编程专栏收录该内容

27 篇文章 0 订阅

订阅专栏

一、默认成员函数。
如图所示：

当我们自己定义的类中没有下列函数的时候，编译器调用系统自动生成的下列函数，因此，了解这些函数就很重要。

在这里插入图片描述
二、构造函数。

定义：

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

#include<iostream>
using namespace std;
class Test
{
public:
	Test(int date = 0)  //构造函数
	{
		_date = date;
	}
	//Test(int date = 0) :_date(date)  //初始化方法二
	//{}
private:
	int _date;
};
int main()
{
	Test t1(3);
	return 0;
}

2.特征：

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

#include<iostream>
using namespace std;

class Test
{
public:
	Test()
	{}
	Test(int date = 0)//参数可以有初始值。
	{
		_date = date;
	}
private:
	int _date;
};

int main()
{
	Test t1();//调用第一个构造函数
	Test t2(2);//调用有参数的构造函数
	return 0;
}

⑤如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
⑥无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
- 注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
一般我们对类中的成员变量命名以_name 形式命名进行区分。

三、析构函数。
1.概念：
析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。
2.特征：
析构函数是特殊的成员函数。
其特征如下：

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

#include<iostream>
using namespace std;

class string
{
public:
	string(const char* str = "asdf")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~string()
	{
		free(_str);
	}
private:
	char* _str;
};

四、拷贝构造函数。

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

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

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

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year, int month, int day) 
		: _year(year),
		  _month(month),
		  _day(day)
	{} 

	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2001,6,22);
	Date d2(d1);
	return 0;
}

③若未显示定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝我们叫做浅拷贝，或者值拷贝。
④有时候编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，但有些地方还是需要我们自己去实现拷贝构造函数。

#include<iostream>
using namespace std;

class String
{
public:
	String(const char* str = "asdf")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	String(const String& s) : _str((char*)malloc(strlen(s._str) + 1))
	{ 
		strcpy(_str, s._str); 
	}
	~String()
	{
		free(_str);
	}
private:
	char* _str;
};
int main()
{
	String s1;
	String s2(s1);
	return 0;
}

五、赋值运算符重载。

运算符重载。
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数。
①函数名字为：关键字operator后面接需要重载的运算符符号。
②函数原型：返回值类型 operator操作符(参数列表)。
注意：
①不能通过连接其他符号来创建新的操作符：比如operator@
②重载操作符必须有一个类类型或者枚举类型的操作数用于内置类型的操作符，其含义不能改变，
③作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符
④有一个默认的形参this，限定为第一个形参 * 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。

#include<iostream>
using namespace std;

class Date 
{
public:    
	Date(int year = 1900, int month = 1, int day = 1)
	{ 
		_year = year;
		_month = month;
		_day = day;
	}
	~Date()
	{

	}
	Date operator+(const Date& d)//+ 的运算符重载
	{
		_year = _year + d._year;
		_month = _month + d._month;
		_day = _day + d._day;
		return *this;
	}
private:    
	int _year;
	int _month; 
	int _day;
};

2.赋值运算符重载。（编译器在执行过程中会自行构建，但我们也可自己定义）
赋值运算符主要有四点：
①参数类型 const 类名& s;
②返回值 (类名)
③检测是否自己给自己赋值
④返回*this
⑤一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

#include<iostream>
using namespace std;

class String
{
public:
	String(const char* str = "asd")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	String(const String& s) : _str((char*)malloc(strlen(s._str) + 1))
	{
		strcpy(_str, s._str);
	}
	String& operator=(const String& s) //运算符=的重载
	{
		if (this != &s)        
		{
			char* pStr = new char[strlen(s._str) + 1];            
			strcpy(pStr, s._str);            
			delete[] _str;            
			_str = pStr; 
		}                
		return *this;
	}
	~String()
	{
		free(_str);
	}
private:
	char* _str;
};
int main()
{
	String s1("hello ");
	String s2 = s1;
	return 0;
}

六、取地址和const取地址重载
这两个默认成员函数一般不用重新定义，编译器默认会生成。

#include<iostream>
using namespace std;

class String
{
public:
	String(const char* str = "asd")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	String(const String& s) : _str((char*)malloc(strlen(s._str) + 1))
	{
		strcpy(_str, s._str);
	}
	String& operator=(const String& s)    
	{
		if (this != &s)        
		{
			char* pStr = new char[strlen(s._str) + 1];            
			strcpy(pStr, s._str);            
			delete[] _str;            
			_str = pStr; 
		}                
		return *this;
	}
	String* operator&()
	{

	}
	const String* operator&()const
	{

	}
	~String()
	{
		free(_str);
	}
private:
	char* _str;
};
int main()
{
	String s1("hello ");
	String s2 = s1;
	return 0;
}