C++类的六个默认函数

于 2024-08-22 16:08:08 发布
阅读量673 收藏 11
点赞数 10
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lihaolihao111111/article/details/141232435
版权

类的六个默认函数

如果一个类中什么成员都没有，这个类就叫做空类

但是类中什么都没有吗？答案是否定的，类中什么都没有的时候，编译器会默认生成六个默认成员函数

默认成员函数：用户没有显示实现（用户没有写），编译器会自动实现的函数

构造函数

构造函数虽然里面有一个构造的词语，但是和构造没有任何关系，它的作用是对数据成员进行初始化

构造函数的引入

下面有一段代码

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 date1;
	date1.init(2024, 8, 15);
	date1.print();


	return 0;
}

上面的代码定义的一个日期类，下面对代码进行两点说明：

1.为什么我们定义变量的时候要在前面加一个" _",比如，_year,_month,_day

答：就用上面的代码来解释，比如上面的初始化函数，里面的形参数是year,month,day,如果你成员变量也写成year，month，day的话，形参写成别的单词你又不好辨别

2.关于构造函数的引入

有的时候我们会忘记对类进行初始化，比如我们学的数据结构中的栈和队列，如果忘记初始化了， 你在去插入一个值，程序就会崩溃，这时候就显示出构造函数的作用了，会帮你自动初始化成员变量

构造函数的特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任
务并不是开空间创建对象，而是初始化对象。
其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

class Date
{

public:
	Date()                     //这是一个构造函数
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date date1;
	date1.print();


	return 0;
}

运行结果：

从上面的代码运行结果来看，当对类进行实例化的时候，会自动调用构造函数来对数据成员进行初始化

class Date
{

public:
	Date()                     //这是一个构造函数(无参构造函数)
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	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 date1;
	date1.print();
	
	Date date2(2024, 8, 15);        //有参构造函数的，在实例化的时候在后面加上要初始化的值            
                                    //即可，调用无参构造函数的话，什么也不用写，正常实例话 
                                    //对象就行
	date2.print();


	return 0;
}

运行结果：

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

比如下面的：

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 date1;
	date1.print();
	
	


	return 0;
}

你如果把上面你写的构造函数的代码注释掉，程序是会正常运行的，但是如果你不注释掉，程序会报错，因为你写了构造函数，编译器不会生成无参构造函数，你调用的方式又不是有参函数的调用的方式

6. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会
生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默
认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的
默认构造函数并没有什么用？
解答：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;
}

运行结果：

7.C++针对编译器生成的默认构造函数对于内置类型不初始化做了补丁，即就是内置类型在

声明的时候可以给一个默认值

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	
	int _year=1;
	int _month=1;
	int _day=1;
	
};
int main()
{
	Date d;
	d.Print();
	return 0;
}

运行结果：

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

总结

1.一般情况下我们都要自己写一个默认构造函数，因为有的编译器自己生成构造函数对于内置类型是不做处理的，还是随机值

2.有的情况下不用自己写，比如

class Stack         //定义一个栈

{

public:

        //这里自己要实现一个构造函数

private:

        int *_arr;

        int _size;

        int _capacity;

            

};

class MyQueue

{

 private:

        Stack st1;

        Stack st2;

};

上面的虽然不用自己写，但是在嵌套的里面还是要写一个，也就是说，MyQueue里面不用写，但是Stack里面是要写的，因为Stack里面也有内置类型，不写的话有的编译器是不做处理的

析构函数

在学习数据结构的时候，比如我们的栈和队列，有时候老是忘记调用Destory函数，在C语言中要担心这个问题，但是在C++中，你是不用担心这个问题的，因为C++的析构函数会自动帮你处理这个问题

析构函数和构造函数的功能正好相反，是自动对对象进行销毁，当程序要结束的时候，（一般情况下一语句是return 的时候）就会调用默认的析构函数

析构函数的特性

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构
函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	// 其他方法...
	~Stack()                         //析构函数
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};
void TestStack()
{
	Stack s;
	s.Push(1);
	s.Push(2);
}

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};

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

运行结果： 

总结

1.有资源需要清理的时候需要自己写析构函数，比如：        栈和队列，里面的指针类型在堆上面开辟的，程序结束后需要手动去清理的

2.有的类里面不需要写析构函数

a.没有资源需要清理的，比如日期类的，里面定义了int double类的，程序结束后会自动销毁的

b.内置类型没有需要清理的，剩下的是自定义类型，但是要看自定义类型里面是否需要写

拷贝构造函数

特征

1. 拷贝构造函数是构造函数的一个重载形式

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

class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
   // Date(const Date d)       //不可以这样写，会引发无穷递归
	Date(const Date& d)       //可以这样写
	{
		cout << "Date(const Date&d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1;
	Date d2(d1);           //这样写是拷贝构造
	//Date d2=d1;          //这样写也是拷贝构造
	return 0;
}

运行结果：

3.对于自定义类型，函数传值传参会调用它的拷贝构造

class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date&d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void func(Date d)
{
	d.Print();
}
int main()
{
	Date d1;
	//Date d2(d1);
	//Date d2=d1;
	func(d1);
	return 0;
}

 函数运行结果：

这也能解释上面为什么说拷贝构造传递参要采用引用的方式，而采用传值的方式会引发无穷递归，

 4. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Date
{
public:
	Date(int year=1,int month=1,int day=1)
	{
		_year = year;
		_month = month;
		_day = day;
		_arr = &day;
	}
	~Date()
	{
		free(_arr);
		_arr = nullptr;
	}
	
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	int* _arr;
};


int main()
{
	Date d1;
	Date d2(d1);
	
	
	return 0;
}

程序运行结果：

从运行结果来看，程序崩溃了，因为我们没有写拷贝构造函数，编译器自动生成的拷贝构造函数是是按值拷贝，所以这里创建的两个对象的_arr指向同一块空间，程序结束的时候会析构两次，但是第一次指针指向的空间已经为空了，第二次去释放一个空的空间程序自然会崩溃

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝

所以这里我们应该写一个深拷贝，只需要申请一个和被拷贝对象大小一样的空间就行了，我们以一个栈为例

Stack(const Stack& st)
{
	_array = (DataType*)malloc(sizeof(DataType) * st._capacity);
	if (NULL == _array)
	{
		perror("malloc申请空间失败!!!");
		return;
	}

	memcpy(_array, st._array, sizeof(DataType) * st._size);

	_size = st._size;
	_capacity = st._capacity;
}

总结

 上面第二点：自定义里面有自定义类型的，如果第二个自定义类型里面涉及到资源申请的，同样需要在第二个自定义里面写拷贝构造，只是第一个不需要而已

赋值运算符重载

运算符号重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其
返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表）

比如下面的

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//设置成为公有
	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;
}

int main()
{
	Date d1(2024, 8, 20);
	Date d2(2024, 8, 21);

	//隐式调用，两种方式都行
	cout << operator==(d1, d2) << endl;
    //转换调用,实际上就是operator==()函数
	cout << (d1 == d2) << endl;

    
	return 0;
}

运行结果：

1. 其实从上面不难看出，运算符重载极大的增加了代码的可读性，以前写相等的函数名字可能写

compare，equal甚至组合起来的单词，但是，如果有人不认识这些单词怎么办，所以，运算符重载极大的增强了代码的可读性

2.上面的函数在外面无法访问类里面的元素，有以下几个解决方案：

1、提供这些成员get函数和set函数,比如

int getyear()

{

        return _year;

}                                //当然，这个函数是要写在类里面的

2、友元 ，后面再讲

 3、重载为成员函数(一般使用这种)

注意


1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐
藏的this

5. .*  ::   sizeof  ？:   . 注意以上5个运算符不能重载。

除了上面的第4点，其余的第五点没有什么讲的

第四点举例子：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator==(const Date & d)
	{
			return _year == d._year && _month == d._month
				&& _day == d._day;
			
	}
	

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 8, 20);
	Date d2(2024, 8, 21);
	
	cout << (d1 == d2) << endl;
	cout << d1.operator==(d2) << endl;
	return 0;
}

代码说明：

d1.operator==(d2),其中，d1是第一个参数，d2是第二个参数，还有，上面的函数相当于

d1.operator(Date*this,const Date&d2)

拷贝构造和赋值构造的区别

赋值构造又叫赋值重载

下面，用一段代码来说明两者之间的区别：

int main()
{
	Date d1(2024, 4, 14);

	// 拷贝构造
	// 一个已经存在的对象，拷贝给另一个要创建初始化的对象
	Date d2(d1);
	Date d3 = d1;

	Date d4(2024, 5, 1);

	// 赋值拷贝/赋值重载
	// 一个已经存在的对象，拷贝赋值给另一个已经存在的对象
	d1 = d4;

	return 0;
}

函数的引用返回和直接返回

Date func()
{
    Date d(2024, 8, 20);
    return d;
}                                               //直接返回

Date&func()
{
    Date d(2024, 8, 20);
    return d;
}                                               //引用返回，返回的是d的别名

直接返回

直接返回，返回的是值的一份临时拷贝，每次调用函数的时候，都会建立函数的栈帧，等到函数结束的时候，里面的东西也会被销毁掉

 引用返回

通过前面的学习，我们都知道，引用就是对变量起一个外号，对引用怎么操作原变量也就怎么操作，如果返回的是其别名，但是函数栈帧已经销毁了，所以接收到的值已经不是之前的那个东西了

class Date
{
public:
	Date(int year, int month, int day)
	{
		cout << "Date(int year, int month, int day)" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date&d)" << endl;
	}
	bool operator==(const Date & d)
	{
			return _year == d._year && _month == d._month
				&& _day == d._day;
			
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	

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

Date&func()
{
	Date d(2024, 8, 20);
	return d;
}

int main()
{
	Date ref=func();
	ref.Print();
	return 0;
}

程序运行结果：

通过运行结果的第三行，我们能够看见，打印的是随机值，可以说明的是，该变量已经被销毁了

总结： 

赋值重载函数 

1. 赋值运算符重载格式
参数类型：const T&，传递引用可以提高传参效率
返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
检测是否自己给自己赋值
返回*this ：要复合连续赋值的含义

int i=0,j=1,k=2;

i=j=k;

从左到右边赋值，j=k返回的类型是int ,这是规定，同样，在类中，如果要连续赋值的话，必须要写一个返回类型,比如下面的，但是，如果是只有两个对象，可写可不写

上面的函数，其实 

Date operator=(const Date& d)
{
	_year = d._year;
	_month = d._month;
	_day = d._day;
	return *this;
}

int main()
{
	Date d1(2022, 2, 2);
	Date d2(2024, 2, 4);
	d2 = d1;
	d2.Print();
	return 0;
}   
//为了节省面积，其余的这里就不实现了

运行结果：

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

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现
一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值
运算符重载只能是类的成员函数。

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注
意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符
重载完成赋值

这里和之前的几个默认函数一样

4.如果类中涉及到资源管理，那么需要自己写

lihao lihao
关注
  • 10
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值