【初识C++】万字简单说懂 类与对象的默认成员函数（中）

已于 2022-10-31 16:30:55 修改
阅读量457 收藏
点赞数
分类专栏： C++ 文章标签： c++ 算法 开发语言
于 2022-10-12 16:54:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ahaooooooo/article/details/127149772
版权

文章目录

1、前言

本章介绍类与对象中的默认成员函数。当一个类中没有任何成员时，我们称这个类为空类，而在空类中并不是真正的空，编译器会自动生成以下几个默认成员函数。

默认成员函数：用户不显示实现，编译器自动生成的成员函数（我们不写编译器自己生成，我们写编译器不生成）。

默认成员函数有：
1、【初始化和清理】：构造函数和析构函数。
2、【拷贝复制】：拷贝构造和赋值运算符重载函数
3、【取地址重载】：普通对象和const对象取地址

 

2、构造函数

  在C语言实现一些数据结构的时候，我们可能老是忘记初始化数据或者销毁数据，或者是每次对初始化和销毁都需要留心感到很麻烦。
  实现C++的大佬也可能有这样的顾虑，所以就设计了默认成员函数，使得在创建对象的同时编译器就自动调用了默认成员函数。

2.1 构造函数的特性

功能：构造函数在对象创建的同时，编译器通过调用构造函数完成对对象的初始化。

特征：

  1. 构造函数的函数名和类名要一样。
  2. 构造函数没有返回值
  3. 对象实例化后，编译器自动调用构造函数。
  4. 构造函数可以重载。

看代码：

class Test
{
public:
	//无参构造函数
	Test()
	{
		_e1 = 1;
		_e2 = 2;
		_e3 = 3;
	}
	//带参构造函数
	Test(int e1, int e2, int e3)
	{
		_e1 = e1;
		_e2 = e2;
		_e3 = e3;
	}
private:
	int _e1;
	int _e2;
	int _e3;
};

int main()
{
	Test t1; // 调用无参构造函数
	Test t2(1, 2, 3); // 调用带参构造函数
	//Test t3(); //错误写法 会让编译器误以为是一个函数声明
	return 0;
}

由于构造函数是支持重载的，在上面代码中有一个无参构造函数和一个有参构造函数，我们可以给上面两个函数简化一下，毕竟我们学过缺省函数嘛。

这样写更能适应多个场景，同时也支持两种调用方式

class Test
{
public:
	Test(int e1 = 1, int e2 = 2, int e3 = 3)
	{
		_e1 = e1;
		_e2 = e2;
		_e3 = e3;
	}
private:
	int _e1;
	int _e2;
	int _e3;
};

int main()
{
	Test t1; // 默认1，2，3
	Test t2(2,3,4); //2,3,4
	return 0;
}

 

2.2 编译器对构造函数的处理

当然对于构造函数，如果我们写了，编译器就不会生成了，下面看看如果我们不写呢？

先看一段代码：

class Test
{
public:
	void func1()
	{
		cout << _e1 << endl;
		cout << _e2 << endl;
		cout << _e3 << endl;
	}
private:
	int _e1;
	int _e2;
	int _e3;
};

int main()
{
	Test t1;
	t1.func1();
	return 0;
}

在这里插入图片描述

再看以下代码

class Temp
{
public:
	Temp()
	{
		cout << "Time()" << endl;
		_t1 = 0;
		_t2 = 0;
		_t3 = 0;
	}
private:
	int _t1;
	int _t2;
	int _t3;
};


class Test
{
public:
	void func()
	{
		cout << _e1 << endl;
		cout << _e2 << endl;
		cout << _e3 << endl;
	}
private:
	// 基本类型(内置类型)
	int _e1;
	int _e2;
	int _e3;
	// 自定义类型
	Temp _t;
};
int main()
{
	Test d;
	d.func();
	return 0;
}

在这里插入图片描述

结论是:

  当我们没有在类中写构造函数的时候，编译器会自动生成构造函数，自动生成的构造函数对内置类型不做处理，但会对自定义类型做处理，调用自定义类型的构造函数。

如果我们想要对内置类型做处理怎么办？
在C++11中打了个补丁，可以对成员变量声明时给个缺省值（不占物理空间，只是标识）。

class Temp
{
public:
	Temp()
	{
		cout << "Time()" << endl;
		_t1 = 0;
		_t2 = 0;
		_t3 = 0;
	}
private:
	int _t1;
	int _t2;
	int _t3;
};


class Test
{
public:
	void func()
	{
		cout << _e1 << endl;
		cout << _e2 << endl;
		cout << _e3 << endl;
	}
private:
	// 基本类型(内置类型)
	int _e1 = 1;
	int _e2 = 2;
	int _e3 = 3;
	// 自定义类型
	Temp _t;
};
int main()
{
	Test d;
	d.func();
	return 0;
}

在这里插入图片描述

 

应用举例:
用栈实现队列
队列的构造函数就不用写了。

class Stack
{
public:
	Stack()
	{
		_a = NULL;
		_capacity = _top = 0;
	}
private:
	int* _a;
	int _capacity;
	int _top;
};

class Queue
{
public:
	void push(size_t x)
	{}
private:
	Stack _PushSt;
	Stack _PopSt;
};

int main()
{
	Queue q1;
	return 0;
}

总结：

如果默认生成的能满足你的需求，那就不用写。

 

2.3 默认构造函数

让我们再跳回这个代码，如果只留带参构造函数，这时编译器不会自己生成构造函数了，如果我们调用的时候不传参，这个时候就会出现问题了。

class Test
{
public:
	//带参构造函数
	Test(int e1, int e2, int e3)
	{
		_e1 = e1;
		_e2 = e2;
		_e3 = e3;
	}
private:
	int _e1;
	int _e2;
	int _e3;
};

int main()
{
	Test t1(1, 2, 3); // 正常运行
	//Test t2; //编译错误
	return 0;
}

在这里插入图片描述
这里说的默认构造函数是什么?
默认构造函数分为这几种:

  1. 无参的构造函数。
  2. 全缺省的构造函数。
  3. 编译器生成的构造函数。

所以创建对象没有默认传参的话，一定得有默认构造函数。

 

3、析构函数

3.1 析构函数的特征

前面学习的构造函数是用来初始化对象的，而析构函数是用来清除对象所占资源（不是销毁对象）的函数。

特征：

  1. 析构函数名是在类名前加个~。
  2. 无参数无返回值，所以不能重载
  3. 一个类只能有一个析构函数，如果写了编译器就不生成，不然编译器会生成
  4. 析构函数在对象生命周期结束时自动调用。

看代码了解特性：

class Temp
{
public:
	Temp()
	{
		cout << "Time()" << endl;
		_t1 = 0;
		_t2 = 0;
		_t3 = 0;
	}

	~Temp()
	{
		cout << "~Temp()" << endl;
	}
private:
	int _t1;
	int _t2;
	int _t3;
};

class Test
{
public:
	void func()
	{
		cout << _e1 << endl;
		cout << _e2 << endl;
		cout << _e3 << endl;
	}

	~Test()
	{
		cout << "~Test()" << endl;
	}
private:
	// 基本类型(内置类型)
	int _e1 = 1;
	int _e2 = 2;
	int _e3 = 3;
	// 自定义类型
	Temp _t;
};
int main()
{
	Test d;
	d.func();
	return 0;
}

在这里插入图片描述

  对象d销毁的时候，清除Test类的资源，所以先调用~Test()，在清除到Temp类型数据的时候再进入Temp类调用 ~Temp()，最后完成整个对象d的资源清除。

但实际上对于栈区里的数据，编译器在程序结束也就自动销毁了，所以这里的析构函数可写可不写。

 

3.2 编译器对析构函数的处理

在上面我们了解了通过自己写的析构函数程序是怎么运行的。
那么接下来让我们看看编译器生成的析构函数。

下面是一个用栈实现队列的部分：

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{

		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

class Queue
{
public:
	void Push(DataType x)
	{
		_Pushst.Push(x);
	}
private:
	Stack _Pushst;
	Stack _Popst;
};


int main()
{
	Queue q;
	q.Push(1);
	q.Push(2);
	return 0;
}

初始化过程：

  在创建对象q的时候，调用编译器生成的类Queue构造函数，在这个构造函数中再调用类Stack的构造函数最后完成了q的初始化。

释放资源过程：

  在对象q的生命周期结束时，调用编译器生成的类Queue析构函数，在这个析构函数中再调用类Stack的析构函数完成了q的资源释放。

总结：
 当只有栈中的数据需要消除时，析构函数可写可不写，当有资源（如动态内存、关闭文件）需要释放的时候编译器的生成只是一个"连接"，最终总有一个类中是需要自己写析构函数的。

有资源释放的需求要写，默认可以处理的不写。
 

4、拷贝构造函数

拷贝构造函数是一个特殊的构造函数，用已有的对象创建新的对象时，编译器自动调用对新的对象进行初始化。

4.1 拷贝构造函数的特征

拷贝构造函数特征：

  1. 函数名和类名一样，是构造函数的重载形式
  2. 没有返回值，参数只有一个且必须是类类型已有的对象的引用。
  3. 用类类型对象创建新对象时，编译器自动调用。

看代码看特征：

class Test
{
public:
	Test(int e1 = 1, int e2 = 2, int e3 = 3)
	{
		_e1 = e1;
		_e2 = e2;
		_e3 = e3;
	}

	//其实注释了这个函数也是一样的结果
	//加const 防止d的值被更改
	Test(const Test& d)
	{
		cout << "Test(const Test& d)" << endl;
		_e1 = d._e1;
		_e2 = d._e2;
		_e3 = d._e3;
	}

	void func()
	{
		cout << _e1 << endl;
		cout << _e2 << endl;
		cout << _e3 << endl;
	}
private:
	int _e1;
	int _e2;
	int _e3;
};
int main()
{
	Test d1(2, 3, 4);
	Test d2(d1);
	d2.func();
	return 0;
}

在这里插入图片描述

Test d1(2, 3, 4); 构造 初始化
Test d2(d1); 构造 给d2初始化

 

4.2 拷贝构造函数的引用参数

为什么拷贝构造函数的参数必须用引用？

先分析一下这段代码

class Test
{
public:
	Test(int e1 = 1, int e2 = 2, int e3 = 3)
	{
		cout << "Test()" << endl;
	}

	//其实注释了这个函数也是一样的结果
	//加const 防止d的值被更改
	Test(const Test& d)
	{
		cout << "Test(const Test& d)" << endl;
	}

private:
	int _e1;
	int _e2;
	int _e3;
};

void func1(const Test d)
{
	cout << "func1(const Test d)" << endl;
}

void func2(const Test& d)
{
	cout << "func1(const Test& d)" << endl;
}

int main()
{
	Test d1;
	func1(d1);
	func2(d1);
	return 0;
}

运行结果：
在这里插入图片描述
实际步骤：

  1. 创建d1对象，调用构造函数。
  2. 调用func1传值，传值先对实参d1拷贝，第一次调用拷贝构造函数后将形参传给func1，打印。
  3. 引用传参不需要拷贝，所以直接打印。

结论：
对象传值，需要调用拷贝构造，所以如果拷贝构造函数传值，那么就会反复调用自己，最后造成死循环。
 

4.3 编译器对拷贝构造函数的处理

如果未显示定义拷贝构造函数，编译器会生成默认的拷贝构造。

对于内置类型

还是这段代码

class Test
{
public:
	Test(int e1 = 1, int e2 = 2, int e3 = 3)
	{
		_e1 = e1;
		_e2 = e2;
		_e3 = e3;
	}

	//其实注释了这个函数也是一样的结果
	//加const 防止d的值被更改
	//Test(const Test& d)
	//{
		//cout << "Test(const Test& d)" << endl;
		//_e1 = d._e1;
		//_e2 = d._e2;
		//_e3 = d._e3;
	//}

	void func()
	{
		cout << _e1 << endl;
		cout << _e2 << endl;
		cout << _e3 << endl;
	}
private:
	int _e1;
	int _e2;
	int _e3;
};
int main()
{
	Test d1(2, 3, 4);
	Test d2(d1);
	d2.func();
	return 0;
}

对于一些内置类型就算没有写拷贝构造函数，结果还是一样的，因为编译器生成的拷贝构造函数完成了值拷贝。

但有一些内置类型，如果靠编译器生成的拷贝构造就会出问题。

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{

		_array[_size] = data;
		_size++;
	}


	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack st;
	st.Push(1);
	st.Push(2);
	Stack st1(st);
	return 0;
}

在这里插入图片描述

程序运行结果：程序崩溃
默认拷贝构造是浅拷贝，属于值拷贝，两个对象的指针都指向一个空间。
当浅拷贝两个动态空间的指针值时，就会发生错误，因为最后会对一个空间析构两次，程序也就崩溃了。

深拷贝通过将建立新的空间，拷贝相同的数据放入新空间，就能实现有效拷贝。

//深拷贝的拷贝构造函数写法
	Stack(const Stack& st)
	{
		_array = (int*)malloc(sizeof(int) * st._capacity);
		if (_array == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_array, st._array, sizeof(int) * st._size);
		_size = st._size;
		_capacity = st._capacity;
	}

结论：
需要写析构函数的类，需要拷贝构造函数。
不需要写析构函数的类，默认拷贝构造函数也够用。

对于自定义类型：

#include <iostream>
using namespace std;

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		cout << "stack构造" << endl;
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(DataType data)
	{

		_array[_size] = data;
		_size++;
	}
	Stack(const Stack& st)
	{
		cout << "stack拷贝构造" << endl;
		_array = (int*)malloc(sizeof(int) * st._capacity);
		if (_array == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_array, st._array, sizeof(int) * st._size);
		_size = st._size;
		_capacity = st._capacity;
	}


	~Stack()
	{
		cout << "stack析构" << endl;
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};


class Queue
{
public:
	void Push(DataType x)
	{
		_Pushst.Push(x);
	}
private:
	Stack _Pushst;
	Stack _Popst;
};


int main()
{
	Queue q;
	q.Push(1);
	q.Push(2);
	Queue q1(q);
	return 0;
}

在这里插入图片描述

Queue类可以不写拷贝构造函数，对于自定义类型编译器自动生成的拷贝构造函数会自动调用Stack类的拷贝构造函数

 

5、运算符重载和赋值重载

5.1 运算符重载

为什么要对运算符进行重载？

  如果有一个日期的对象，我们需要计算距今100天后的具体日期，简单内置的+肯定是不能完成这个工作的，对于类似情况，就需要我们对运算符进行重载。

 

5.1.1 运算符重载的使用

运算符重载是一个特殊的函数
函数名：operator后面接需要重载的运算符
原型：返回值 operator操作符(参数)

如：

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

运算符重载很注重代码的可读性，所以调用的形态很易懂。
如：

class Date
{
public:	
	//构造
	Date(int year = 2022, int month = 10, int day = 9)
	{
		_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;
	}
	
	//析构
	~Date()
	{
		cout << "~Date()" << endl;
	}
	
	//打印
	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}
	
	//==重载函数 写类里的方式
	//bool operator==(const Date& d)
	//{
	//	return _year == d._year
	//		&& _month == d._month
	//		&& _day == d._day;
	//}
	
	//==重载函数声明
	bool operator==(const Date& d);

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

//==重载函数 写类外的方式
bool Date::operator==(const Date& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

int main()
{
	Date d1(2022, 10, 8);
	d1.Print();

	Date d2(d1);
	//写法和平时一样 但实际d1 == d2 是 d1.operator==(d2);
	cout << (d1 == d2) << endl;

	return 0;
}

在这里插入图片描述
 
让我们通过==重载函数的实现看一些东西

bool Date::operator==(const Date& d)
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}
  1. 为什么参数只有一个d，不是(const Date& d1, const Date& d2)，这是因为在参数中有一个隐藏的this指针。
  2. &的使用相较传值可以避免d的拷贝构造，从而提高效率，相较传指针可读性更强。
  3. const避免d的值被改变，并且使得函数调用适合多种情况（可以传Date类型，也可以传const Date类型），因为权限可以缩小不能扩大。

注意：

  1. 不能通过连接其它符号来创建新的操作符，比如operator@。
  2. 重载操作符必须有一个类类型参数，不然就失去了重载的意义。
  3. 运算符重载后不能改变运算符本该有的含义。
  4. sizeof 、? : 、:: 、. 、*. 这5个操作符不能进行重载。

 

5.1.2 实现多种运算符重载

在实现一定的操作符重载函数后，对于实现一些其它的操作符重载函数我们可以复用

比如：

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

bool Date::operator>(const Date& d)
{
	if (_year > d._year)
	{
		return true;
	}
	else if (_year == d._year && _month > d._month)
	{
		return true;
	}
	else if (_year == d._year && _month == d._month && _day > d._day)
	{
		return true;
	}

	return false;
}

bool Date::operator>=(const Date& d)
{
	return (*this) == d || (*this) > d;
}

bool Date::operator<=(const Date& d)
{
	return !((*this) > d);
}

bool Date::operator<(const Date& d)
{
	return !(*this >= d);
}

bool Date::operator!=(const Date& d)
{
	return !(*this == d);
}

以下函数都定义在类外，所以需要添加类作用域限定符。

int Date::GetMonthDay(int year, int month)
{
	int MonthArr[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (year % 4 == 0 && year % 400 != 0)
	{
		MonthArr[2] = 29;
	}

	return MonthArr[month];
}

Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= abs(day);
	}
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day = _day - GetMonthDay(_year, _month);
		_month++;
		if (_month > 12)
		{
			_year++;
			_month = 1;
		}
	}

	return *this;
}

Date Date::operator+(int day)
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}

 
前置++和后置++的实现与区别
前置++，直接返回+1后的结果。
后置++，拷贝一个临时变量，对象+1，再返回临时变量。

//后置++
//C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
//自动传递
Date Date::operator++(int)
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}
//前置++
Date& Date::operator++()
{
	*this += 1;
	return *this;
}

 

日期相减的重载

int Date::operator-(const Date& d)
{
	Date max = *this;
	Date min = d;
	int flag = 1;

	if (max < min)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (max != min)
	{
		++min;
		++n;
	}

	return n*flag;
}

 

5.2 赋值运算符重载

当我们想完成一个d1 = d2 的赋值重载

	Date d1(2022, 10, 8);
	d1.Print();

	Date d2;
	d2 = d1;

赋值运算符重载也有自己的格式

  • 参数类型:const 类类型& 提高效率
  • 返回值类型：类类型& 提高效率，并且使得赋值能够连续
  • 考虑自己给自己赋值的情况
  • 返回*this使得符合赋值连续
5.2.1 赋值运算符的赋值连续

下面我们通过代码理解它的格式
这里重点是理解连续赋值是怎么实现的

#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 9)
	{
		_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;
	}

	~Date()
	{
		cout << "~Date()" << endl;
	}

	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}

	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		return *this;
	}



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

int main()
{
	Date d1(2022, 10, 8);
	d1.Print();

	Date d2;
	Date d3(2022, 10, 9);
	d2 = d3 = d1; //先右到左 (d3 = d1)的返回值和d2比 等价 d2 = (d3 = d1);

	return 0;
}

因为需要返回值和下一个对象进行比较，所以需要返回*this。

为什么不能返回d呢？

	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;

		return *this;
	}

依然是权限的问题，d返回类型变成了Date&，权限扩大，如果要返回d返回类型需要改为const Date&，但这可能不是我们需要得到的类型。

 

5.2.2 赋值和拷贝的区别

赋值需要在对象都存在时才能调用。

Date d1(2022, 10, 8);
Date d2;
d2 = d1;

拷贝是用一个对象创建一个新的对象

Date d1(2022, 10, 8);
Date d2(d1);

那么这样写呢？

Date d1(2022, 10, 8);
Date d2=d1;

本质是创建一个新的对象，再对其初始化，所以是拷贝。
 

5.2.3 赋值运算符重载不能写在类外

首先，如果我们在类中不自己实现一个赋值运算符重载，在调用时，编译器会自动生成并且以字节序进行值拷贝，所以如果写在类外就会就会与编译器生成的冲突。

比如这种情况我们不写赋值重载

#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 9)
	{
		_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;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2022, 10, 8);
	Date d2;
	Date d3(2022, 10, 9);
	d2 = d3 = d1; //先右到左 (d3 = d1)的返回值和d2比 等价 d2 = (d3 = d1);

	return 0;
}

就算没有写赋值重载，编译器生成的也能实现。

但对于这种情况，编译器自动生成的就会出问题

class stack
{
public:
	//构造
	stack(int capacity = 4)
	{
		cout << "stack(int capacity = 4)" << endl;
		_a = (int*)malloc(sizeof(int*) * capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}

		_capacity = capacity;
		_top = 0;
	}
	
	//拷贝构造
	stack(const stack& st)
	{
		cout << "stack(const stack& st)" << endl;
		_a = (int*)malloc(sizeof(int*) * st._capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(_a, st._a, sizeof(int) * st._top);
		_capacity = st._capacity;
		_top = st._top;
	}
	//入栈
	void Push(int x)
	{
		//扩容
		_a[_top++] = x;

	}
	
	//析构
	~stack()
	{
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}
private:
	int* _a;
	int _capacity;
	int _top;
};

int main()
{
	stack st1(100);
	st1.Push(1);
	st1.Push(2);

	stack st2(st1);
	st2.Push(10);
	st2.Push(20);

	stack st3(20);
	st3.Push(100);
	st3.Push(200);

	st1 = st2 = st3;
}

结果就是程序崩溃，对一个空间多次析构，还是值拷贝的问题，所以我们需要自己实现赋值重载。

大致和拷贝构造函数一样，值得注意的一个细节就是考虑自己赋值给自己的情况。

	stack& operator=(const stack& st)
	{
		//自己等于自己
		if (this != &st)
		{
			free(_a);
			_a = (int*)malloc(sizeof(int*) * st._capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				exit(-1);
			}
			memcpy(_a, st._a, sizeof(int) * st._top);
			_capacity = st._capacity;
			_top = st._top;
		}
		
		return *this;

	}

 

6、const成员和取地址重载

被const修饰的对象，表示不能对该对象进行任何修改，只能拥有可读的权限，所以const对象的调用是我们需要讨论的问题。

 

6.1 const成员

当我们用一个const对象调用一个函数时，由于编译器生成的this指针默认类型是 类* 类型，当我们传const 类* 类型，就会发生权限扩大，这是禁止的。

#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year = 2022, int month = 10, int day = 9, int tmp = 4)
	{
		_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;
	}

	~Date()
	{
		cout << "~Date()" << endl;
	}

	void Print()
	{
		cout << _year << " " << _month << " " << _day << endl;
	}

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

int main()
{
	const Date d1;
	d1.Print();
	return 0;
}

在这里插入图片描述
而解决这个问题只需要在Print函数右边加上const，编译器会自动将this指针调整成const Date* 类型。

void Print() const
{
	cout << _year << " " << _month << " " << _day << endl;
}

因为函数加const后，带上const的对象和不加const的对象都能正常调用，所以如果函数没有修改对象的操作，那么最好是加上const。

 

6.2 取地址重载

还是实现日期类的取地址重载，注意对加const的对象要有特别处理。

	//一般不用自己定义 除非要让别人得到特定内容
	// 如:
	// 要求这个类的对象不让取地址
	Date* operator&()
	{
		/*return nullptr;*/
		return this;
	}

	const Date* operator&() const
	{
		/*return nullptr;*/
		return this;
	}

但其实对于取地址重载编译器生成的都能用，我们一般不用写，除非是想让调用的人看不到，这时候可以在重载中返回nullptr。

本章完~

Ahao_te
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++入门-初识类与对象
10-22
思维导图
C++从初识到模板类-大一，面向对象编程
03-14
这是我大一上学期刚学完C语言后，开始学习C++，开始接触...在学习C++过程中，加深了我对编程的理解，比如python为什么很多方法可以对不同的数据类型进行操作，同时模板类，泛型编程帮助我可以自己完成一个库的实现。
单片机与DSP中的初识PIC单片机
12-06
PIC单片机的型号繁多，对初学者来说实在不好应付，容易混淆，以下作一简单分类，希望有助于初学者学习： 初档8位单片机：PIC12C5XXX／16C5X系列 　PIC16C5X系列是最早在市场上得到发展的系列，因其价格较低，且有...
c++程序设计实验指导：类和对象初识
03-04
c++程序设计实验指导 第一次编写类和对象的程序，着重体验对类和对象的使用。
c++程序设计实验指导：类和对象初识(2)
03-09
c++程序设计实验指导 继续体验对类和对象的使用，重温基本算法。学会开发多文档的项目。
C 练习实例36 - 求100之内的素数
2401_82561004的博客
04-27 972
质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。// Copyright © 2013年 编程字典. All rights reserved.求100之内的素数。
C#(C Sharp)学习笔记_类【十五】
最新发布
追求细节，成就完美
05-01 214
类（Class）是面向对象程序设计（OOP，Object-Oriented Programming）实现信息封装的基础。类是一种用户定义的引用数据类型，也称类类型。每个类包含数据说明和一组操作数据或传递消息的函数。类的实例称为对象。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 1003
C++ Primer (第五版）第八章习题部分答案
手搓顺序表（C语言）
m0_62646213的博客
04-23 696
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c入门基础题（3）
梦昼初
04-26 893
1、找出数组中最大元素的位置（下标值） 输入 多组测试，每组先输入一个不大于10的整数n 然后是n个整数 输出 输出这n个整数中最大的元素及下标值 样例输入 4 1 4 5 6 样例输出 6 3 #include<stdio.h> int main(){ int a[20]; int n,x=0,y,z,s,m,f; int i,j; while(scanf("%d",&n)!=EOF){ for(i=1;i<=n;i++){ scanf("%d",&y)
(C++) this_thread 函数介绍
cuber-lotus的博客
04-24 1598
在C++11起，标准规定了标注的并发库。头文件为并发支持库 (C++11 起) - cppreference.com其包含线程、原子操作、互斥、条件变量和 future 的内建支持。而其中有一个namespace为，里面有四个重要的全局函数，其实现都与当前系统环境和编译器强绑定。std::this_thread 符号索引 - cppreference.comget_id()yield()返回当前线程的id。这个id是一个的内部类型。其实现依附于所在平台。
手搓带头双向循环链表（C语言）
m0_62646213的博客
04-28 473
带头双向循环链表的实现与测试，优劣分析
C++笔试强训day7
cy18779588218的博客
04-26 447
因为我见了很多DFS的题目返回值都为bool，因此我认为DFS必须以bool作返回值，结果导致浪费很多时间还得不到成果。然后我写代码的时候代码思路没跟上原本思路，直接把所有的l，r，len都存起来，然后最后再遍历一遍存起来的数。回想起才发现思路清晰了，但是代码写的一塌糊涂，其实可以直接在遍历的过程中不断更新l，r，len就可以了。我没有经过思考，所有就把所有情况都遍历了，真的很傻的行为，虽然过了，但是很繁琐嘞，太多情况了。因为是排序过后的，所以只需要遍历包含第一个数在内的四种情况即可。
从C语言到C++过渡篇（快速入门C++）
2302_80023639的博客
04-27 702
C语言->C++的过渡（快速入门C++） 命名空间、C++输入与输出（cout && cin）、缺省参数、函数重载 引用、内联函数、auto 关键字、区别于C语言的空指针（nullptr）
【C++】const修饰输入参数
zjh2883的博客
04-28 164
在这个例子中，printValue函数的参数被声明为const，这意味着函数内部不会修改value的值。如果尝试修改value，编译器将会报错，从而避免了潜在的bug。在C++中，传参时使用const可以防止在函数内部不小心修改了传入的参数，这样可以提高代码的健壮性和可维护性。const表示函数内部不会修改传入的参数。，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。,那么加const修饰可以防止意外地改动该指针，起到保护作用。
【C++】析构函数的作用及其使用
原小明
04-28 576
当一个对象的生命周期结束时，无论是对象所在的作用域结束（例如，局部对象在函数退出时）、对象被delete（针对动态分配的对象）、或者容器（如std::vector）自动销毁其元素时，析构函数都会被自动调用。在继承关系中，当派生类的析构函数执行完毕后，基类的析构函数会被自动调用，确保了基类资源的正确释放。同样，如果一个类包含了另一个类的对象作为成员，那么当该类的析构函数被调用时，成员对象的析构函数也会被自动调用，递归地清理整个对象结构。然而，对于管理了资源的类，最好显式定义析构函数以确保资源的正确清理。
[C++]22:C++11_part_one
2201_75943325的博客
04-28 746
默认成员函数：构造+析构 拷贝构造+拷贝赋值构造 取地址重载+const取地址重载 -------> 移动构造+移动赋值 ， 一共有8个默认成员函数！1.如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
C++ 堆结构和堆排序（从顶到底/从底到顶的大顶堆）+ 优化
呵呵哒!的博客
05-01 270
heapInsert、heapify方法的单次调用，时间复杂度O(logn)，完全二叉树的结构决定的。依次弹出堆内最大值并排好序，和上面一样的操作流程，这里就不再演示了。，尤其是和比较器结合之后，后面博客会重点讲述。三、从底到顶建立大根堆。二、从顶到底建立大根堆。堆结构比堆排序有用的多。
C++中把Lambda 表达式作为参数传递给模板函数。
weixin_42944928的博客
04-27 161
【代码】C++中把Lambda 表达式作为参数传递给模板函数。
c++中unordered_set的函数
09-05
需要注意的是，在C语言中，unordered_set的函数并不是直接在C标准库中提供的，而是通过自定义的unordered_set类实现的。所以，使用unordered_set函数之前，需要先引入相应的头文件，并使用对应的命名空间。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值