【C++奇妙冒险】拷贝构造函数、运算符重载（赋值重载|const成员|取地址重载|const取地址重载）

2024-06-04 6559阅读

文章目录

  • 前言
  • 🚩拷贝构造函数
    • 🫧概念
    • 🫧特征
    • 🫧默认生成的拷贝构造
    • 🫧default关键字（浅谈）
    • 🚩运算符重载
      • 🫧概念
      • 🫧运算符重载注意事项
      • 🫧封装如何保证？
      • 🚩赋值运算符重载
        • 🫧赋值运算符重载格式
        • 🫧返回值引用和不加引用的区别
        • 🫧赋值运算符只能重载成类的成员函数不能重载成全局函数
        • 🫧编译器生成的默认赋值运算符重载
        • 🚩const成员
          • 🫧const 成员
          • 🫧const修饰成员函数
            • 🔺小结
            • 🫧思考
            • 🚩取地址及const取地址重载
              • 🫧取地址重载
              • 🫧const取地址重载
              • 🫧取地址重载和const取地址重载一般不需要重载

                前言

                🚩拷贝构造函数

                创建对象时，可否创建一个与已存在的对象一模一样的新对象呢？

                可以的

                用拷贝构造就能做到：

                	Date d1(2024, 5, 28);
	Date d2(d1);
	return 0;

                什么原理？我们下面会讲，反正不是张力…

                🫧概念

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

                🫧特征

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

                • 拷贝构造函数是构造函数的一个重载形式
                • 拷贝构造的参数只有一个且必须是类类型对象的引用（必须使用引用）

                  注：使用传值方式编译器直接报错，因为会引发无穷递归调用

                • 若未显示定义，编译器会生成默认的拷贝构造

                  默认的拷贝构造函数对象按内存存储，按字节序完成拷贝（浅拷贝or值拷贝） 原型：类名 （const 类名& 形参） 例如：Date（const Date& d）

                  拷贝构造函数的用法：

                  代码：

                  #include
using namespace std;
class Date
{
public:
	Date(int year = 2024, int month = 5, int day = 28)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 拷贝构造函数
	// Date d2(d1)
	Date(const Date& d) // 不传引用会无限递归调用
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout 
	Date d1(2024, 5, 28);
	d1.Print();
	Date d2(d1); //拷贝构造 ，生成一个和d1一模一样的对象
	d2.Print();
	return 0;
}

public:
	// 构造函数
	Time(int hour = 1, int minute = 1, int second = 1)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	// 拷贝构造 
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
		cout 
public:
	// 构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d1(2024, 5, 28);
	// 用已经存在的 d1 拷贝构造 d2 此处会调用Date类的拷贝构造
	// 但Date类并未显示定义拷贝构造 则编译器会为Date类自动生成一个默认拷贝构造函数
	Date d2(d1);
	return 0;
}

public:
	//拷贝构造函数
	Time(const Time& t)
	{
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
private:
	// 内置类型
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

public:
	Date(int year = 2024, int month = 5, int day = 28)
	{
		_year = year;
		_month = month;
		_day = day;
	}
//private:
	int _year;
	int _month;
	int _day;
};
// d1 == d2
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, 5, 28);
	Date d2(2024, 5, 27);
	cout 
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// d1 == d2
	// 函数原型：bool operator==(Date* this,const Date& d2)
	// 这里需要注意的是，左操作数是this，指向调用函数的对象
	bool operator==(const Date& d2)
	{
		return _year == d2._year
			&& _month == d2._month
			&& _day == d2._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 5, 20);
	Date d2(2024, 5, 21);
	cout 
public:
	Date(int year = 2024, int month = 5, int day = 28)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date& operator=(const Date& d)
	{
		// &d 是取地址
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;// 返回左操作数d1
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 5, 28);
	Date d2(2024, 5, 27);
	d1 = d2;// 两个已经存在的对象
	return 0;
}
...}
Date operator=(const Date& d)  // 去掉引用
{...}

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;
		cout 
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;//返回d1
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 5, 28);
	Date d2(2024, 5, 20);
	Date d3(2024, 5, 21);
	d1 = d2 = d3;
	return 0;
}

		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}

public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	int _year;
	int _month;
	int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& d)
{
	if (&left != &d)
	{
		left._year = d._year;
		left._month = d._month;
		left._day = d._day;
	}
	return left;
}
// 报错

public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 5, 28);
	Date d2(2024, 5, 20);
	d1 = d2;
	return 0;
}

public:
	Time(int hour = 1, int minute = 1, int second = 1)
	{
		_hour = hour;
		_minute = minute;
		_second = second;
	}
	Time& operator=(const Time& t)
	{
		if (this != &t)
		{
			_hour = t._hour;
			_minute = t._minute;
			_second = t._second;
		}
		return *this;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	Date d1(2024, 5, 20);
	Date d2(2024, 6, 21);
	d1 = d2;
	return 0;
}

public:
	Date()
	{
		_year = 2024;
		_month = 5;
		_day = 29;
	}
	void Print()
	{
		cout 
	Date d1;
	d1.Print();
	Date d2;
	d2.Print();
	return 0;
}

public:
	Date()
	{
		_year = 2024;
		_month = 5;
		_day = 29;
	}
	void Print()
	{
		cout 
	Date d1;
	d1.Print();
	// 同样的代码 就加了个关键字
	const Date d2;
	d2.Print();
	return 0;
}

public:
	Date()
	{
		_year = 2024;
		_month = 5;
		_day = 29;
	}
	void Print() const
	{
		cout 
	Date d1;
	d1.Print();
	const Date d2;
	d2.Print();
	return 0;
}

public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date* operator&()
	{
		// this是指针，指向对象地址，返回this就是返回对象地址
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024, 5, 28);
	cout 
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	const Date* operator&() const
	{
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	const Date d1(2024, 5, 28);
	cout 
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	const Date d1(2024, 5, 28);
	cout

相关阅读：

1、动态IP的VPS使用指南及优势深度解析

2、轻松卸载VPS搭建的Shadowsocks（SS）操作指南，一步步实现无障碍卸载

3、VPS远程桌面功能开通指南，轻松实现远程访问和操作！

4、搬瓦工VPS使用秘籍，轻松上手，极致体验玩转VPS！

5、车VPS定位使用详解，轻松掌握车辆定位技巧，让出行更安心！

    高速稳定云服务器25元起
    免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

    相关阅读

    目录[+]