1.类的6个默认成员函数
2.构造函数
- 2.1概念
- 2.2 特性
- 2.3 初始化列表
- 2.4 explicit关键字
3.析构函数
- 3.1 概念
- 3.2 特性
4.拷贝构造函数
- 4.1 概念
- 4.2 特征
5.赋值操作符重载
- 5.1 运算符重载
- 5.2 赋值运算符重载
- 5.3 默认拷贝函数与赋值运算符重载的问题
6.const成员函数

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

如果一个类中什么成员都没有，则成为空类。空类中真的什么都没有吗？答案是否定的，任何一个类在定义时我们什么都不写的情况下，都会自动生成下面6个默认成员函数。

【C++入门】类的默认成员函数1.类的6个默认成员函数2.构造函数3.析构函数4.拷贝构造函数5.赋值操作符重载6.const成员函数

2.构造函数

2.1概念

对于Date类，可以通过SetDate公有方法给对象设置内容，但如果每次创建对象都调用该方法来初始化对象未免太过于麻烦，可不可以在对象创建的同时初始化呢？

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

	void Display()
	{
		cout << _year << "-"<< _month << "-"<< _day;
	}

private:
	int _year;
	int _month;
	int _day;
};

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

2.2 特性

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

其特征如下：

函数名与类名相同
无返回值(返回值部分什么都不写，不是void)
对象实例化时编译器自动调用对应的构造函数
构造函数可以重载

class Date
{ 
public :
	// 1.无参构造函数
	Date ()
	{}
 
// 2.带参构造函数
	Date (int year, int month , int day )
	{
		_year = year ;
		_month = month ;
		_day = day ;
	}

private :
	int _year ;
	int _month ;
	int _day ;
};

void TestDate()
{
	Date d1; // 调用无参构造函数
	Date d2 (2021, 6, 4); // 调用带参的构造函数
 
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	Date d3(); 
}

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义了，编译器便不再生成。

class Date
{
public:
 /*
 // 如果用户显式定义了构造函数，编译器将不再生成
	Date (int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day；
	}
 */
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	// 没有定义构造函数，对象也可以创建成功，并初始化成员变量为成随机值
	//此处调用的就是默认的构造函数
 	Date d; 
}

无参的构造函数和全缺省的构造函数都称为默认构造函数，由于两者不能构成重载，因此默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器生成的构造函数，都可以认为是默认成员函数。

以下测试函数能通过编译吗？

// 默认构造函数
class Date
{ 
public:
	Date()
	{
		_year = 1900 ;
		_month = 1 ;
		_day = 1;
	}
 
	Date (int year = 1900, int month = 1, int day = 1)
	{
	_year = year;
	_month = month;
	_day = day;
	}
private :
	int _year ;
	int _month ;
	int _day ;
};

void Test()
{
	Date d1;
}

不能，因为无参的构造函数和全缺省的构造函数不能构成重载，相当于在类中重复定义了默认构造函数。

在我们没有显式提供构造函数的情况下，编译器会生成默认构造函数，但看起来默认构造函数并没有什么用。例如d对象调用了编译器生成的默认构造函数之后，其内数据依旧是随机值

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数

class Time
{
public:
Time()
 {
	cout << "Time()" << endl;
	_hour = 0;
	_minute = 0;
	_second = 0;
}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};

int main()
{
	Date d;
	return 0;
}

但是，虽然上述的构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造函数体中的语句只能称为赋值，而不能称为初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

于是就引入了初始化列表的概念。

2.3 初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

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

【注意】：

每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）
类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量
const成员变量
自定义类型成员（该类没有默认构造函数的情况下）

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型中成员变量，一定会先使用初始化列表进行初始化。
成员变量在类中的声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

2.4 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(2020);
		// 用一个整形变量给日期类型对象赋值
		// 实际编译器背后会用2021构造一个匿名对象，最后用匿名对象给d1对象进行赋值
		d1 = 2021;
	}

以上代码中，d1 = 2021语句没有报错的原因是，2021通过单个参数的构造函数创建了一个匿名对象，并用匿名对象给d1进行赋值。

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

3.析构函数

3.1 概念

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

3.2 特性

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

其特征如下：

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

typedef int SeqDataType;

class SeqList
{
public:
	SeqList(int capacity = 10)
	{
		_arr = (SeqDataType*)malloc(sizeof(SeqDataType)*capacity);
		if (nullptr == _arr)
		{
			assert(0);
			return;
		}
		_size = 0;
		_capacity = capacity;
	}

	~SeqList()
	{
		free(_arr);
		_arr = nullptr;
		_size = 0;
		_capacity = 0;
	}

private:
	SeqDataType* _arr;
	int _size;
	int _capacity;
};

关于编译器自动生成的析构函数，对会自定类型成员调用它的析构函数。

class String
{
public:
	String(const char* str = "Jack")
	{
		_str = (char*)malloc(sizeof(char)*(strlen(str) + 1));
		if (nullptr == _str)
		{
			assert(0);
			return;
		}
		strcpy(_str, str);
	}

	~String()
	{
		free(_str);
		_str = nullptr;
	}

private:
	char* _str;
};

class Person
{
private:
	String _name;
	int _age;
};

4.拷贝构造函数

4.1 概念

在创建对象时，可否创建一个与某一对象一样的对象呢？

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

4.2 特征

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

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

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

	//拷贝构造函数
	Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2021, 6, 14);
	Date d2(d1);

	return 0;
}

如果是传值调用，在函数调用时会生成一份实参的临时拷贝，此时又需要调用拷贝构造函数来生成这份形参，形成无限递归。

若未显式定义，系统生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储字节序来完成拷贝，我们称为浅拷贝，或者值拷贝。

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(sizeof(char)*(strlen(str) + 1));
		if (nullptr == _str)
		{
			assert(0);
			return;
		}
		strcpy(_str, str);
	}

	~String()
	{
		free(_str);
		_str = nullptr;
	}
	
private:
	char* _str;
};

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

可以预想，在上面的代码中，s1，s2是两个不同的结构体，但s1._str和s2_str的值是一样的，都指向了存储字符常量"hello"的同一块地址空间，由析构函数的概念，在s1和s2的生命周期结束后，s1和s2会分别调用析构函数来回收资源，字符常量"hello"所在的地址空间就会涉及到多次释放造成程序崩溃，因此在类中如果涉及到资源管理时，浅拷贝是不合适的。

5.赋值操作符重载

5.1 运算符重载

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

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

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

注意：

不能通过连接其他符号来创建新的操作符：比如operator@
重载操作符必须有一个类类型或者枚举类型的操作数
运算符重载函数不一定是类的成员函数，其也可以定义在全局作用域中，但是要注意的是：用于内置类型的操作符，其含义不能改变，例如：内置类型的整形+，不能改变其含义
作为类成员的重载函数时，其形参看起来必操作数数目少1（类成员函数的参数列表中隐含有一个默认的形参this指针，限定为第一个形参）
.*、::、sizeof、?:、. 注意以上5个运算符不能重载。（常在笔试题中出现）。

5.2 赋值运算符重载

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

	//拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._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;
};

赋值运算符主要有4点：

参数类型
返回值
检查是否给自己赋值
返回*this（连续赋值时须有返回值）

5.3 默认拷贝函数与赋值运算符重载的问题

一个类如果没有显示定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的拷贝（浅拷贝）。

那么编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像日期类这样的类是没必要的。

类似的，浅拷贝有时并不能够满足我们的需求，因此有时需要我们自定义一个赋值运算符重载函数。

6.const成员函数

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

注意const在修饰成员函数时，是放在参数部分的后面。

class Date
{ 
public :
	void Display ()
	{
		cout<<"Display ()" <<endl;
		cout<<"year:" <<_year<< endl;
		cout<<"month:" <<_month<< endl;
		cout<<"day:" <<_day<< endl<<endl ;
	}
	void Display () const
	{
		cout<<"Display () const" <<endl;
		cout<<"year:" <<_year<< endl;	cout<<"month:" <<_month<< endl;
		cout<<"day:" <<_day<< endl<<endl;
	}
private :
	int _year ; // 年
	int _month ; // 月
	int _day ; // 日
};
void Test ()
{
	Date d1 ;
	d1.Display ();
 
	const Date d2;
	d2.Display ();
}

对于const对象与非const对象，有以下结论：

const对象只能调用const成员函数，而不能调用普通成员函数（因为在普通成员函数中对象可以被修改）
非const对象既可以调用const成员函数，又可以调用普通成员函数

【C++入门】类的默认成员函数1.类的6个默认成员函数2.构造函数3.析构函数4.拷贝构造函数5.赋值操作符重载6.const成员函数

目录

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

2.构造函数

2.1概念

2.2 特性

2.3 初始化列表

2.4 explicit关键字

3.析构函数

3.1 概念

3.2 特性

4.拷贝构造函数

4.1 概念

4.2 特征

5.赋值操作符重载

5.1 运算符重载

5.2 赋值运算符重载

5.3 默认拷贝函数与赋值运算符重载的问题

6.const成员函数

继续阅读

POJ 1284 Primitive Roots (欧拉函数&原根定理)

CQ V1.0分词bates(基于双数组tire树)—应该是目前最快的中文分词算法

线程同步，可重入锁，synchronized

成员函数初始化列表

2021-08-13c++——类之操作符重载

swmm与lisflood-fp源码如何一起编译 CMake命令

Windows下VS开发环境环境安装工程项目设置关于Debug和Release的提示

一文看懂字符串的加减乘除

C++ 第十五周报告1--《冒泡法排序》

C++实现简单顺序表

对象锁和全局锁

iview后台管理模版

C经典书籍笔记——C陷阱与缺陷②(语法陷阱之优先级)一、错误案列二、优先级规律

线性表之顺序表的实现

C++判断素数、求最大公约数代码判断一个数是否为素数求两个数的最大公约数

SequoiaDB巨杉数据库C++驱动概述